Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
ToJ Minarki CMS
#1
ToJ Minarki CMS
Tsunokiette
Aug 21 2006

This is a locked, single-post thread from Creation Asylum.  Archived here to prevent its loss.
No support is given.  If you are the owner of the thread, please contact administration.


Comes with support for any party size, bars, and allows you to choose whether or not to use chapters.

Also allows for you to enable/disable cursor memory within the menu, as well as supports faces.

The faces need to be 80 * 80 and in a folder named Faces in the Characters folder. They need to have the same name as the characters have in the database, eg "Aluxes".

Customization is found near the top of the script, make sure to set your first chapter's name near the top too.


To change it within the game use -
Code:
$game_party.chapter = 'Name of Chapter'



To enable/disable the cursor memory, simply use
Code:
$game_party.enable_memory
or
Code:
$game_party.disable_memory


Add this above main -
Code:
#==============================================================================
# ** ToJ Minarki CMS (supports unlimited party sizes)
#------------------------------------------------------------------------------
# Tsunokiette
# Version 1
# 2006-08-21
#==============================================================================

# CUSTOMIZATION

$chapters_enabled = true # Set to false if you don't want to use chapters.
$font = 'Times New Roman' # Font you wish the menu to use.

#------------------------------------------------------------------------------
# Begin Game_Party Edit
#------------------------------------------------------------------------------
class Game_Party
   # Alias Initialization
   alias :tsuno_TojMinarkiCMS_GameParty_initialize :initialize
   def initialize
       @chapter = "REPLACE WITH NAME OF FIRST CHAPTER"
       @cursor_memory = []
       # Command Menu Index
       @cursor_memory[0] = 0
       # Data Menu Index
       @cursor_memory[1] = 0
       # Party Selection Index
       @cursor_memory[2] = 0
       # Enabled/Disabled (0 = ON, 1 = OFF)
       @cursor_memory[3] = 0
       #____________________
       # Run Original Initialization
       #____________________
       tsuno_TojMinarkiCMS_GameParty_initialize
   end
   def chapter
       return @chapter
   end
   def cursor_memory
       return [0,0,0,1] unless @cursor_memory[3] == 0
       return @cursor_memory
   end
 def enable_memory
   @cursor_memory[3] = 0
 end
 def disable_memory
   @cursor_memory[3] = 1
 end
end
#------------------------------------------------------------------------------
# End Game_Party Edit
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Begin Game_Actor Edit
#------------------------------------------------------------------------------
class Game_Actor < Game_Battler
   def exp_gained
       return @exp - @exp_list[@level]
   end
   def needed_exp
       return @exp_list[@level+1] - @exp_list[@level]
   end
end
#------------------------------------------------------------------------------
# End Game_Actor Edit
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# Define Base for Custom Windows (New Methods)
#------------------------------------------------------------------------------
class Window_Base
   #--------------------------------------------------------------------------
   # * Draw Outlined Text
   #--------------------------------------------------------------------------
   def draw_outlined_text(x_coor, y_coor = '', width = 0, height = nil, text = nil, align = 0)
       if x_coor.is_a?(Rect)
           x = x_coor.x
           y = x_coor.y
           width = x_coor.width
           height = x_coor.height
           text = y_coor
           align = width
       else
           x = x_coor
           y = y_coor
           width = width
           height = height
           text = text
           align = align
       end
       original_color = self.contents.font.color.dup
       self.contents.font.color = Color.new(0, 0, 0, 255)
       self.contents.draw_text(x - 1, y, width, height, text, align)
       self.contents.draw_text(x + 1, y, width, height, text, align)
       self.contents.draw_text(x, y - 1, width, height, text, align)
       self.contents.draw_text(x, y + 1, width, height, text , align)
       self.contents.font.color = original_color
       self.contents.draw_text(x, y, width, height, text, align)
   end
   #--------------------------------------------------------------------------
   # * Draw Face
   #--------------------------------------------------------------------------
   def draw_actor_face(actor, x, y)
   bitmap = RPG::Cache.character("Faces/" + actor.name,actor.character_hue)
   src_rect = Rect.new(0, 0, 80, 80)
   self.contents.blt(x, y, bitmap, src_rect)
 end
   def gradiated_color?(colors,width,percentage)
       if colors.size == 1
           return colors[0]
       elsif colors.size > 1
           i = 0
           sections_per = (1.0 / colors.size)
           equationa = (sections_per * colors.size)
           equationb = (sections_per * (colors.size - 1))
           if equationa >= percentage and equationb < percentage
               i = (colors.size - 1)
           else
               for j in 0..(colors.size - 1)
                   equationc = (sections_per * (j + 1))
                   equationd = (sections_per * (j + 2))
                   if equationc < percentage and equationd > percentage
                       i = j + 1
                   end
               end
           end
           if i == (colors.size - 1)
               r = colors[i-1].red + (colors[i].red - colors[i-1].red) / width * (percentage * 100.0)
               g = colors[i-1].green + (colors[i].green - colors[i-1].green) / width * (percentage * 100.0)
               b = colors[i-1].blue + (colors[i].blue - colors[i-1].blue) / width * (percentage * 100.0)
               a = colors[i-1].alpha + (colors[i].alpha - colors[i-1].alpha) / width * (percentage * 100.0)
               return Color.new(r,g,b,a)
           else
               r = colors[i].red + (colors[i+1].red - colors[i].red) / width * (percentage * 100.0)
               g = colors[i].green + (colors[i+1].green - colors[i].green) / width * (percentage * 100.0)
               b = colors[i].blue + (colors[i+1].blue - colors[i].blue) / width * (percentage * 100.0)
               a = colors[i].alpha + (colors[i+1].alpha - colors[i].alpha) / width * (percentage * 100.0)
               return Color.new(r,g,b,a)
           end
       end
   end
   def gradiate(x,y,width,height,start,finish)
       for i in 0..width
           r = start.red + (finish.red - start.red) / width * i
           g = start.green + (finish.green - start.green) / width * i
           b = start.blue + (finish.blue - start.blue) / width * i
           a = start.alpha + (finish.alpha - start.alpha) / width * i
           self.contents.fill_rect(x + i,y,1,height,Color.new(r, g, b, a))
       end
   end
   def draw_gradient(x,y,width,height,colors)
       gradient_width = ((width * 1.0) / (colors.size - 1))
       return gradiate(x,y,width,height,colors[0],colors[0]) unless colors.size != 1
       for i in 0..(colors.size - 2)
           x_var = (x + (i * gradient_width))
           gradiate(x_var,y,gradient_width,height,colors[i],colors[i + 1])
       end
   end
   def draw_hp_bar(actor,x,y,width = 150)
       # Determine Percentage
       percentage = ((actor.hp * 1.0) / actor.maxhp)
       # Define Colors
       green = [Color.new(0,80,0,255),Color.new(0,210,0,255)]
       red = [Color.new(140,0,0,255),Color.new(255,60,60,255)]
       gradient_a = [red[0],red[0],green[0],green[0],green[0],green[0]]
       gradient_b = [red[1],red[1],green[1],green[1],green[1],green[1]]
       start = gradiated_color?(gradient_a,width - 4,percentage)
       finish = gradiated_color?(gradient_b,width - 4,percentage)
       border_1 = Color.new(0,0,0,255)
       border_2 = Color.new(251,245,210,255)
       empty_1 = Color.new(115,115,115,255)
       empty_2 = Color.new(80,80,80,255)
       empty_3 = Color.new(45,45,45,255)
       # Create Bar
       draw_gradient(x,y,width,10,[border_1])
       draw_gradient(x+1,y+1,width-2,8,[border_2])
       if actor.hp != actor.maxhp and actor.hp != 0
           draw_gradient(x+2,y+2,width-4,6,[start,finish])
           line_width = (percentage * (width - 4))
           empty_x = ((x + 3) + line_width)
           empty_width = ((width - 4) - line_width)
           draw_gradient(empty_x,y+2,empty_width,2,[empty_3])
           draw_gradient(empty_x,y+4,empty_width,2,[empty_2])
           draw_gradient(empty_x,y+6,empty_width,2,[empty_1])
       elsif actor.hp == 0
           draw_gradient(x + 2,y+2,width-4,2,[empty_3])
           draw_gradient(x + 2,y+4,width-4,2,[empty_2])
           draw_gradient(x + 2,y+6,width-4,2,[empty_1])
       elsif actor.hp == actor.maxhp
           draw_gradient(x+2,y+2,width-4,6,[start,finish])
       end
   end
   def draw_sp_bar(actor,x,y,width = 150)
       # Determine Percentage
       percentage = ((actor.sp * 1.0) / actor.maxsp)
       # Define Colors
       green = [Color.new(100,0,65,255),Color.new(255,100,200,255)]
       red = [Color.new(140,0,0,255),Color.new(255,60,60,255)]
       gradient_a = [red[0],red[0],green[0],green[0],green[0],green[0]]
       gradient_b = [red[1],red[1],green[1],green[1],green[1],green[1]]
       start = gradiated_color?(gradient_a,width - 4,percentage)
       finish = gradiated_color?(gradient_b,width - 4,percentage)
       border_1 = Color.new(0,0,0,255)
       border_2 = Color.new(251,245,210,255)
       empty_1 = Color.new(115,115,115,255)
       empty_2 = Color.new(80,80,80,255)
       empty_3 = Color.new(45,45,45,255)
       # Create Bar
       draw_gradient(x,y,width,10,[border_1])
       draw_gradient(x+1,y+1,width-2,8,[border_2])
       if actor.sp != actor.maxsp and actor.sp != 0
           draw_gradient(x+2,y+2,width-4,6,[start,finish])
           line_width = (percentage * (width - 4))
           empty_x = ((x + 3) + line_width)
           empty_width = ((width - 4) - line_width)
           draw_gradient(empty_x,y+2,empty_width,2,[empty_3])
           draw_gradient(empty_x,y+4,empty_width,2,[empty_2])
           draw_gradient(empty_x,y+6,empty_width,2,[empty_1])
       elsif actor.sp == 0
           draw_gradient(x + 2,y+2,width-4,2,[empty_3])
           draw_gradient(x + 2,y+4,width-4,2,[empty_2])
           draw_gradient(x + 2,y+6,width-4,2,[empty_1])
       elsif actor.sp == actor.maxsp
           draw_gradient(x+2,y+2,width-4,6,[start,finish])
       end
   end
   def draw_exp_bar(actor,x,y,width = 150)
       # Determine Percentage
       percentage = ((actor.exp_gained * 1.0) / actor.needed_exp)
       # Define Colors
       green = [Color.new(115,90,0,255),Color.new(255,225,120,255)]
       red = [Color.new(115,90,0,255),Color.new(255,225,120,255)]
       gradient_a = [red[0],red[0],green[0],green[0],green[0],green[0]]
       gradient_b = [red[1],red[1],green[1],green[1],green[1],green[1]]
       start = gradiated_color?(gradient_a,width - 4,percentage)
       finish = gradiated_color?(gradient_b,width - 4,percentage)
       border_1 = Color.new(0,0,0,255)
       border_2 = Color.new(251,245,210,255)
       empty_1 = Color.new(115,115,115,255)
       empty_2 = Color.new(80,80,80,255)
       empty_3 = Color.new(45,45,45,255)
       # Create Bar
       draw_gradient(x,y,width,10,[border_1])
       draw_gradient(x+1,y+1,width-2,8,[border_2])
       if actor.exp_gained != actor.needed_exp and actor.exp_gained != 0
           draw_gradient(x+2,y+2,width-4,6,[start,finish])
           line_width = (percentage * (width - 4))
           empty_x = ((x + 3) + line_width)
           empty_width = ((width - 4) - line_width)
           draw_gradient(empty_x,y+2,empty_width,2,[empty_3])
           draw_gradient(empty_x,y+4,empty_width,2,[empty_2])
           draw_gradient(empty_x,y+6,empty_width,2,[empty_1])
       elsif actor.exp_gained == 0
           draw_gradient(x + 2,y+2,width-4,2,[empty_3])
           draw_gradient(x + 2,y+4,width-4,2,[empty_2])
           draw_gradient(x + 2,y+6,width-4,2,[empty_1])
       end
   end
   def draw_actor_hp(actor, x, y, width = 144)
       # Draw "HP" text string
       self.contents.font.color = system_color
       draw_outlined_text(x, y - 9, 32, 32, $data_system.words.hp)
       # Calculate if there is draw space for MaxHP
       if width - 32 >= 108
           hp_x = x + width - 108
           flag = true
       elsif width - 32 >= 48
           hp_x = x + width - 48
           flag = false
       end
       w1 = contents.text_size(actor.hp.to_s).width
       w2 = contents.text_size('/').width
       w3 = contents.text_size(actor.maxhp.to_s).width
       x1 = x + width - (w1 + w2 + w3)
       x2 = x + width - (w2 + w3)
       x3 = x + width - w3
       # Draw HP
       self.contents.font.color = actor.hp == 0 ? knockout_color :
       actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
       draw_outlined_text(x1, y - 9, w1, 32, actor.hp.to_s, 2)
       # Draw MaxHP
       if flag
           self.contents.font.color = normal_color
           draw_outlined_text(x2, y - 9, w2, 32, "/", 1)
           draw_outlined_text(x3, y - 9, w3, 32, actor.maxhp.to_s)
       end
       draw_hp_bar(actor, x, y + 13, width)
   end
   def draw_actor_sp(actor, x, y, width = 144)
       # Draw "SP" text string
       self.contents.font.color = system_color
       draw_outlined_text(x, y - 9, 32, 32, $data_system.words.sp)
       # Calculate if there is draw space for MaxHP
       if width - 32 >= 108
           sp_x = x + width - 108
           flag = true
       elsif width - 32 >= 48
           sp_x = x + width - 48
           flag = false
       end
       # Draw SP
       w1 = contents.text_size(actor.sp.to_s).width
       w2 = contents.text_size('/').width
       w3 = contents.text_size(actor.maxsp.to_s).width
       x1 = x + width - (w1 + w2 + w3)
       x2 = x + width - (w2 + w3)
       x3 = x + width - w3
       self.contents.font.color = actor.sp == 0 ? knockout_color :
       actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
       draw_outlined_text(x1, y - 9, w1, 32, actor.sp.to_s, 2)
       # Draw MaxSP
       if flag
           self.contents.font.color = normal_color
           draw_outlined_text(x2, y - 9, w2, 32, "/", 1)
           draw_outlined_text(x3, y - 9, w3, 32, actor.maxsp.to_s)
       end
       draw_sp_bar(actor,x,y + 13,width)
   end
   def draw_actor_exp(actor, x, y, width = 204)
       self.contents.font.color = system_color
       draw_outlined_text(x, y - 9, 40, 32, "Exp")
       self.contents.font.color = normal_color
       w1 = contents.text_size(actor.exp_s).width
       w2 = contents.text_size('/').width
       w3 = contents.text_size(actor.next_exp_s).width
       x1 = x + width - (w1 + w2 + w3)
       x2 = x + width - (w2 + w3)
       x3 = x + width - w3
       draw_outlined_text(x1, y - 9, w1, 32, actor.exp_s, 2)
       draw_outlined_text(x2, y - 9, w2, 32, "/", 1)
       draw_outlined_text(x3, y - 9, w3, 32, actor.next_exp_s)
       draw_exp_bar(actor,x,y + 13,width)
   end
end
       
class Menu_Help < Window_Base
   attr_accessor    :text
   def initialize
       super(0, 0, 640, 80)
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       @text = ''
       refresh
   end
   def refresh
       self.contents.clear
       self.contents.font.color = normal_color
       w = self.contents.width
       h = self.contents.height
       draw_outlined_text(0, 0, w, h, @text, 1)
   end
   def set_text(text = '')
       @text = text
       refresh
   end
end

class Menu_Gold < Window_Base
   def initialize
       super(440, 80, 200, 80)
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
   end
   def refresh
       self.contents.clear
       @currency = $data_system.words.gold
       @gold = gold
       w = self.contents.width
       h = self.contents.height / 2
       self.contents.font.color = normal_color
       draw_outlined_text(0, 0, w, h, @currency + ':')
       self.contents.font.color = system_color
       draw_outlined_text(0, h, w, h, @gold, 2)
   end
   def gold
       gold = $game_party.gold
       a = $game_party.gold.to_s.split(//)
       if a.size <= 4
           return gold.to_s
       elsif a.size = 5
           return "#{a[0]}#{a[1]},#{a[2]}#{a[3]}#{a[4]}"
       elsif a.size = 6
           return "#{a[0]}#{a[1]}#{a[2]},#{a[3]}#{a[4]}#{a[5]}"
       elsif a.size = 7
           return "#{a[0]},#{a[1]}#{a[2]}#{a[3]},#{a[4]}#{a[5]}#{a[6]}"
       end
   end
end

class Menu_Time < Window_Base
   def initialize
       super(440, 160, 200, 80)
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
   end
   def refresh
       self.contents.clear
       w = self.contents.width
       h = self.contents.height / 2
       self.contents.font.color = normal_color
       draw_outlined_text(0, 0, w, h, 'Elapsed Time :')
       @total = Graphics.frame_count / Graphics.frame_rate
       hour = @total / 60 / 60
       min = @total / 60 % 60
       sec = @total % 60
       @time = "#{hour}.#{min}.#{sec}"
       self.contents.font.color = system_color
       draw_outlined_text(0, h, w, h, @time, 2)
   end
   def update
       refresh unless @total == Graphics.frame_count / Graphics.frame_rate
       super
   end
end

class Menu_Location < Window_Base
   def initialize
       super(440, 240, 200, 80)
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
   end
   def refresh
       self.contents.clear
       w = self.contents.width
       h = self.contents.height / 2
       self.contents.font.color = normal_color
       draw_outlined_text(0, 0, w, h, 'Location :')
       map_data = load_data('Data/MapInfos.rxdata')
       @map_name = map_data[$game_map.map_id].name
       self.contents.font.color = system_color
       draw_outlined_text(0, h, w, h, @map_name, 2)
   end
end

class Menu_Chapter < Window_Base
   def initialize
       super(440, 320, 200, 80)
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
   end
   def refresh
       self.contents.clear
       w = self.contents.width
       h = self.contents.height / 2
       self.contents.font.color = normal_color
       draw_outlined_text(0, 0, w, h, 'Chapter :')
       @chapter = $game_party.chapter
       self.contents.font.color = system_color
       draw_outlined_text(0, h, w, h, @chapter, 2)
   end
end

class Menu_H_Command < Window_Selectable
   def initialize(commands)
       super(0, 400, 640, 80)
       @commands = commands
       @item_max = @commands.size
       @column_max, @row_max = @item_max, 1
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
       self.index = -1
   end
   def refresh
       self.contents.clear
       for i in 0...@item_max
           draw_item(i, normal_color)
       end
   end
   def draw_item(index, color)
       self.contents.font.color = color
       w = self.contents.width / @item_max
       h = 32
       x = w * index + 4
       rect = Rect.new(x, 8, w, h)
       self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
       draw_outlined_text(rect, @commands[index], 2)
   end
   def update_cursor_rect
       if self.index < 0
           self.cursor_rect.empty
           return
       end
       w = self.contents.width / @item_max
       h = 32
       x = w * index
       self.cursor_rect.set(x, 8, w, h)
   end
end

class Menu_V_Command < Window_Selectable
   def initialize(commands)
       super(0, 80, 200, commands.size * 32 + 32)
       @commands = commands
       @item_max = @commands.size
       self.contents = Bitmap.new(self.width - 32, @item_max * 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
       self.index = -1
   end
   def refresh
       self.contents.clear
       for i in 0...@item_max
           draw_item(i, normal_color)
       end
   end
   def draw_item(index, color)
       self.contents.font.color = color
       y = index * 32
       rect = Rect.new(4, y, self.contents.width - 8, 32)
       self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
       draw_outlined_text(rect, @commands[index], 1)
   end
   def update_cursor_rect
       if self.index < 0
           self.cursor_rect.empty
           return
       end
       y = index * 32
       self.cursor_rect.set(0, y, self.contents.width, 32)
   end
end

class Menu_Status < Window_Selectable
   def initialize
       super(200, 80, 240, 320)
       @item_max = $game_party.actors.size
       @column_max, @row_max = @item_max, 1
       self.contents = Bitmap.new(self.width - 32, self.height - 32)
       self.contents.font.name = $font
       self.contents.font.size = 22
       refresh
   end
   def refresh
       self.contents.clear
       @actor = $game_party.actors[@index]
       self.contents.font.color = Color.new(255, 255, 255, 255)
       tw = contents.text_size('Lvl ' + "#{@actor.level}").width
       draw_outlined_text(0, 0, tw, 32, 'Lvl ' + "#{@actor.level}")
       draw_outlined_text(0, 130, self.contents.width, 32, @actor.name, 1)
   draw_actor_face(@actor,64,32)
       draw_actor_hp(@actor,0,194,self.contents.width)
       draw_actor_sp(@actor,0,226,self.contents.width)
       draw_actor_exp(@actor,0,258,self.contents.width)
   end
   def update_cursor_rect
       cursor_rect.set(0,130,self.contents.width,32)
   end
   def update
       if @actor != $game_party.actors[@index]
           refresh
       end
       super
   end
end

class Scene_End
   def command_cancel
       # Play decision SE
       $game_system.se_play($data_system.decision_se)
       # Switch to menu screen
       $scene = Scene_Menu.new(5,true)
   end
end

class Scene_Load < Scene_File
   alias :orig_init :initialize
   def initialize(from_menu = false)
       @from_menu = from_menu
       orig_init
   end
   def on_cancel
       # Play cancel SE
       $game_system.se_play($data_system.cancel_se)
       if @from_menu
           $scene = Scene_Menu.new(0,true)
       else
           # Switch to title screen
           $scene = Scene_Title.new
       end
   end
end

class Scene_Save < Scene_File
 def on_cancel
   # Play cancel SE
   $game_system.se_play($data_system.cancel_se)
   # If called from event
   if $game_temp.save_calling
     # Clear save call flag
     $game_temp.save_calling = false
     # Switch to map screen
     $scene = Scene_Map.new
     return
   end
   # Switch to menu screen
   $scene = Scene_Menu.new(4,true)
 end
end

class Scene_Menu
   def initialize(index = 0,from_data = false)
       @menu_index = $game_party.cursor_memory[0]
       @from_data = from_data
   end
   def main
       s1 = 'Items'
       s2 = 'Spells'
       s3 = 'Equip'
       s4 = 'Status'
       s5 = 'Save'
       s6 = 'Load'
       s7 = 'End'
       @command = Menu_H_Command.new([s1,s2,s3,s4])
       @command.active = false unless !@from_data
       @command.index = @menu_index unless !@command.active
       @data = Menu_V_Command.new([s5,s6,s7])
       @data.active = false unless @from_data
       @data.index = $game_party.cursor_memory[1] unless !@data.active
       @help = Menu_Help.new
       @gold = Menu_Gold.new
       @time = Menu_Time.new
       @location = Menu_Location.new
       @chapter = Menu_Chapter.new unless !$chapters_enabled
       @status = Menu_Status.new
       @status.visible, @status.active, @status.index = false, false, $game_party.cursor_memory[2]
       Graphics.transition
       loop do
           Graphics.update
           Input.update
           update
           break unless $scene == self
       end
       Graphics.freeze
       @command.dispose
       @data.dispose
       @help.dispose
       @gold.dispose
       @time.dispose
       @location.dispose
       @chapter.dispose unless @chapter.nil?
       @status.dispose
   end
   def update
       update_help
       @command.update
       @data.update
       @help.update
       @gold.update
       @time.update
       @location.update
       @chapter.update unless @chapter.nil?
       @status.update
       if @command.active
           update_command
       elsif @data.active
           update_data
       elsif @status.active
           update_status
       end
   end
   def update_help
       if @command.active
           case @command.index
           when 0
               @help.set_text('View and Use Stored Items')
           when 1
               @help.set_text("View and Cast Learned Spells")
           when 2
               @help.set_text("View and Equip Stored Equipment")
           when 3
               @help.set_text("View Party's Current Status")
           end
       end
       if @data.active
           case @data.index
           when 0
               @help.set_text('Save Current Game')
           when 1
               @help.set_text('Load Saved File')
           when 2
               @help.set_text('End the Current Game')
           end
       end
       if @status.active
           actor = $game_party.actors[@status.index]
           case @command.index
           when 1
               @help.set_text("View and Cast #{actor.name}'s Learned Spells")
           when 2
               @help.set_text("View and Change #{actor.name}'s Current Equipment")
           when 3
               @help.set_text("View #{actor.name}'s Current Status")
           end
       end
   end
   def update_command
       if $game_party.cursor_memory[3] == 0
           $game_party.cursor_memory[0] = @command.index
       end
       if Input.trigger?(Input::B)
           $scene = Scene_Map.new
       end
       if Input.trigger?(Input::A)
           @data.active = true
           @data.index = $game_party.cursor_memory[1]
           @command.active = false
           @command.index = -1
       end
       if Input.trigger?(Input::C)
           case @command.index
           when 0
               $scene = Scene_Item.new
           when 1
               @status.active, @status.visible = true, true
               @status.index = $game_party.cursor_memory[2]
               @command.active = false
           when 2
               @status.active, @status.visible = true, true
               @status.index = $game_party.cursor_memory[2]
               @command.active = false
           when 3
               @status.active, @status.visible = true, true
               @status.index = $game_party.cursor_memory[2]
               @command.active = false
           end
       end
   end
   def update_data
       if $game_party.cursor_memory[3] == 0
           $game_party.cursor_memory[1] = @data.index
       end
       if Input.trigger?(Input::B)
           $scene = Scene_Map.new
       end
       if Input.trigger?(Input::A)
           @command.active = true
           @command.index = $game_party.cursor_memory[0]
           @data.active = false
           @data.index = -1
       end
   if Input.trigger?(Input::C)
     case @data.index
     when 0
       $scene = Scene_Save.new
     when 1
       $scene = Scene_Load.new(true)
     when 2
       $scene = Scene_End.new
     end
   end
   end


def update_status
       if $game_party.cursor_memory[3] == 0
           $game_party.cursor_memory[2] = @status.index
       end
       if Input.trigger?(Input::B)
           @command.active = true
           @status.active, @status.visible = false, false
       end
   if Input.trigger?(Input::C)
     case @command.index
     when 1
       $scene = Scene_Skill.new(@status.index)
     when 2
       $scene = Scene_Equip.new(@status.index)
     when 3
       $scene = Scene_Status.new(@status.index)
     end
   end
   end
end
}




Users browsing this thread: