Problème de Classe

#==============================================================================
#
# ▼ Yanfly Engine Ace - Class System v1.09
# -- Last Updated: 2012.01.29
# -- Level: Normal, Hard
# -- Requires: n/a
#
#==============================================================================

$imported = {} if $imported.nil?
$imported["YEA-ClassSystem"] = true

#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.01.29 - Visual Bug: Disabled classes now have faded icons.
# 2012.01.08 - Compatibility Update: Learn Skill Engine
# 2012.01.05 - Bug Fixed: Equipment no longer gets duplicated.
# 2012.01.04 - Update: Autobattle will no longer use skills not available to
#              that class for specific actors.
# 2012.01.02 - Efficiency Update.
# 2011.12.26 - Added custom command functionality.
# 2011.12.23 - Compatibility Update: Class Specifics.
# 2011.12.22 - Compatibility Update: Ace Menu Engine.
# 2011.12.20 - Compatibility Update: Class Unlock Level.
# 2011.12.19 - Started Script and Finished.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script adds the ability for your player to freely change the classes of
# actors outside of battle from a menu. When changing classes, this script
# gives the option for the developer to choose whether or not classes have
# their own levels (causing the actor's level to reset back to the class's
# level) or to maintain the current level. In addition to providing the ability
# to change classes, equipping a subclass is also doable, and the mechanics of
# having a subclass can also be defined within this script.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# Actor Notetags - These notetags go in the actors notebox in the database.
# -----------------------------------------------------------------------------
#
#
# This will set the default classes as unlocked for the actor. This does not
# override the default classes unlocked in the module, but instead, adds on
# to the number of unlocked classes.
#
# -----------------------------------------------------------------------------
# Class Notetags - These notetags go in the class notebox in the database.
# -----------------------------------------------------------------------------
#
# Sets the icon representing the class to x.
#
#
# string
#

# Sets the text used for the help window in the class scene. Multiple lines in
# the notebox will be strung together. Use | for a line break.
#
# -----------------------------------------------------------------------------
# Script Calls - These commands are used with script calls.
# -----------------------------------------------------------------------------
# $game_actors[x].unlock_class(y)
# This allows actor x to unlock class y, making it available for switching in
# and out in the Class scene.
#
# $game_actors[x].remove_class(y)
# This causes actor x to remove class y from being able to switch to and from.
# If the actor is currently class y, the class will not be removed. If the
# actor's current subclass is y, the subclass will be unequipped.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
#==============================================================================

module YEA
 module CLASS_SYSTEM
   
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # - General Class Settings -
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # These are the general settings regarding the whole script. They control
   # various rules and regulations that this script undergoes. These settings
   # will also determine what a subclass can do for a player.
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   CLASS_MENU_TEXT = "Classe"  # Text that appears in the Main Menu.
   MAINTAIN_LEVELS = false    # Maintain through all classes. Default: false.
   DEFAULT_UNLOCKS = [ 1, 3, 5, 7, 9, 11, 13, 14, 15, 16]  # Classes unlocked by default.
   
   # The display between a primary class and a subclass when written in a
   # window will appear as such.
   SUBCLASS_TEXT = "%s/%s"
   
   # This adjusts the stat rate inheritance for an actor if an actor has a
   # subclass equipped. If you want to disable this, set the rate to 0.0.
   SUBCLASS_STAT_RATE = 0.25
   
   # This adds subclass skill types to the available skill types usable.
   SUBCLASS_SKILL_TYPES = true
   
   # This adds subclass weapons to equippable weapon types.
   SUBCLASS_WEAPON_TYPES = true
   
   # This adds subclass weapons to equippable armour types.
   SUBCLASS_ARMOUR_TYPES = true
   
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # - Class Scene Commands -
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # These settings adjust how the class scene appears. Here, you can adjust
   # the command list and the order at which items appear. These are mostly
   # visual settings. Adjust them as you see fit.
   #
   # -------------------------------------------------------------------------
   # :command        Description
   # -------------------------------------------------------------------------
   # :primary        Allows the player to change the primary class.
   # :subclass        Allows the player to change the subclass.
   #
   # :learn_skill    Requires YEA - Learn Skill Engine
   #
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   COMMANDS =[ # The order at which the menu items are shown.
   # [ :command,  "Display"],
     [ :primary,  "Primaire"],
     [:subclass,  "Sous-Classe"],
     [:learn_skill, "Apprendre"],
   # [ :custom1,  "Custom1"],
   # [ :custom2,  "Custom2"],
   ] # Do not remove this.
   
   #--------------------------------------------------------------------------
   # - Status Class Commands -
   # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   # For those who use scripts to that may produce unique effects for the
   # class menu, use this hash to manage the custom commands for the Class
   # Command Window. You can disable certain commands or prevent them from
   # appearing by using switches. If you don't wish to bind them to a switch,
   # set the proper switch to 0 for it to have no impact.
   #--------------------------------------------------------------------------
   CUSTOM_CLASS_COMMANDS ={
   # :command => [EnableSwitch, ShowSwitch, Handler Method,
      => [          0,          0, :command_name1],
     :custom2 => [          0,          0, :command_name2],
   } # Do not remove this.
   
   # These settings adjust the colour displays for classes.
   CURRENT_CLASS_COLOUR = 17    # "Window" colour used for current class.
   SUBCLASS_COLOUR      = 4      # "Window" colour used for subclass.
   
   # This adjusts the display for class levels if MAINTAIN_LEVELS is false.
   CLASS_LEVEL    = "LV%s"      # Text display for level.
   LEVEL_FONT_SIZE = 16          # Font size used for level.
   
   # This array sets the order of how classes are ordered in the class listing
   # window. Any class ID's unlisted will not be shown.
   CLASS_ORDER = [41..999, 1..40]
   
   # This adjusts the font size for the Parameters window.
   PARAM_FONT_SIZE = 20
   
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # - Switch Settings -
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   # These are the switches that govern whether or not certain menu items will
   # appear and/or will be enabled. By binding them to a Switch, you can just
   # set the Switch ON/OFF to show/hide or enable/disable a menu command. If
   # you do not wish to use this feature, set these commands to 0.
   #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
   SWITCH_SHOW_CLASS      = 0    # Switch that shows Class in Main Menu.
   SWITCH_ENABLE_CLASS    = 0    # Switch that enables Class in Main Menu.
   SWITCH_SHOW_PRIMARY    = 0    # Switch that shows Subclass in Class Menu.
   SWITCH_ENABLE_PRIMARY  = 0    # Switch that enables Subclass in Class Menu.
   SWITCH_SHOW_SUBCLASS  = 0    # Switch that shows Subclass in Class Menu.
   SWITCH_ENABLE_SUBCLASS = 0    # Switch that enables Subclass in Class Menu.
   
 end # CLASS_SYSTEM
end # YEA

#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================

module YEA
 module CLASS_SYSTEM
   module_function
   #--------------------------------------------------------------------------
   # convert_integer_array
   #--------------------------------------------------------------------------
   def convert_integer_array(array)
     result = []
     array.each { |i|
       case i
       when Range; result |= i.to_a
       when Integer; result |= [i]
       end }
     return result
   end
   #--------------------------------------------------------------------------
   # converted_contants
   #--------------------------------------------------------------------------
   DEFAULT_UNLOCKS = convert_integer_array(DEFAULT_UNLOCKS)
   CLASS_ORDER = convert_integer_array(CLASS_ORDER)
 end # CLASS_SYSTEM
 module REGEXP
 module ACTOR
   
   UNLOCKED_CLASSES =
     /<(?:UNLOCKED_CLASSES|unlocked classes):[ ]*(\d+(?:\s*,\s*\d+)*)>/i
   
 end # ACTOR
 module CLASS
   
   ICON_INDEX = /<(?:ICON_INDEX|icon index|icon):[ ](\d+)>/i
   HELP_DESCRIPTION_ON  = /<(?:HELP_DESCRIPTION|help description)>/i
   HELP_DESCRIPTION_OFF = /<\/(?:HELP_DESCRIPTION|help description)>/i
   
 end # CLASS
 end # REGEXP
end # YEA

#==============================================================================
# ■ Switch
#==============================================================================

module Switch
 
 #--------------------------------------------------------------------------
 # self.class_show
 #--------------------------------------------------------------------------
 def self.class_show
   return true if YEA::CLASS_SYSTEM::SWITCH_SHOW_CLASS <= 0
   return $game_switches[YEA::CLASS_SYSTEM::SWITCH_SHOW_CLASS]
 end
 
 #--------------------------------------------------------------------------
 # self.class_enable
 #--------------------------------------------------------------------------
 def self.class_enable
   return true if YEA::CLASS_SYSTEM::SWITCH_ENABLE_CLASS <= 0
   return $game_switches[YEA::CLASS_SYSTEM::SWITCH_ENABLE_CLASS]
 end
 
 #--------------------------------------------------------------------------
 # self.primary_show
 #--------------------------------------------------------------------------
 def self.primary_show
   return true if YEA::CLASS_SYSTEM::SWITCH_SHOW_PRIMARY <= 0
   return $game_switches[YEA::CLASS_SYSTEM::SWITCH_SHOW_PRIMARY]
 end
 
 #--------------------------------------------------------------------------
 # self.primary_enable
 #--------------------------------------------------------------------------
 def self.primary_enable
   return true if YEA::CLASS_SYSTEM::SWITCH_ENABLE_PRIMARY <= 0
   return $game_switches[YEA::CLASS_SYSTEM::SWITCH_ENABLE_PRIMARY]
 end
 
 #--------------------------------------------------------------------------
 # self.subclass_show
 #--------------------------------------------------------------------------
 def self.subclass_show
   return true if YEA::CLASS_SYSTEM::SWITCH_SHOW_SUBCLASS <= 0
   return $game_switches[YEA::CLASS_SYSTEM::SWITCH_SHOW_SUBCLASS]
 end
 
 #--------------------------------------------------------------------------
 # self.subclass_enable
 #--------------------------------------------------------------------------
 def self.subclass_enable
   return true if YEA::CLASS_SYSTEM::SWITCH_ENABLE_SUBCLASS <= 0
   return $game_switches[YEA::CLASS_SYSTEM::SWITCH_ENABLE_SUBCLASS]
 end
   
end # Switch

#==============================================================================
# ■ Numeric
#==============================================================================

class Numeric
 
 #--------------------------------------------------------------------------
 # new method: group_digits
 #--------------------------------------------------------------------------
 unless $imported["YEA-CoreEngine"]
 def group; return self.to_s; end
 end # $imported["YEA-CoreEngine"]
   
end # Numeric

#==============================================================================
# ■ DataManager
#==============================================================================

module DataManager
 
 #--------------------------------------------------------------------------
 # alias method: load_database
 #--------------------------------------------------------------------------
 class < def self.load_database
   load_database_cs
   load_notetags_cs
 end
 
 #--------------------------------------------------------------------------
 # new method: load_notetags_cs
 #--------------------------------------------------------------------------
 def self.load_notetags_cs
   groups = [$data_actors, $data_classes]
   for group in groups
     for obj in group
       next if obj.nil?
       obj.load_notetags_cs
     end
   end
 end
 
end # DataManager

#==============================================================================
# ■ RPG::Actor
#==============================================================================

class RPG::Actor < RPG::BaseItem
 
 #--------------------------------------------------------------------------
 # public instance variables
 #--------------------------------------------------------------------------
 attr_accessor :unlocked_classes
 
 #--------------------------------------------------------------------------
 # common cache: load_notetags_cs
 #--------------------------------------------------------------------------
 def load_notetags_cs
   @unlocked_classes = []
   #---
   self.note.split(/[\r\n]+/).each { |line|
     case line
     #---
     when YEA::REGEXP::ACTOR::UNLOCKED_CLASSES
       $1.scan(/\d+/).each { |num|
       @unlocked_classes.push(num.to_i) if num.to_i > 0 }
     #---
     end
   } # self.note.split
   #---
 end
 
end # RPG::Actor

#==============================================================================
# ■ RPG::Class
#==============================================================================

class RPG::Class < RPG::BaseItem
 
 #--------------------------------------------------------------------------
 # public instance variables
 #--------------------------------------------------------------------------
 attr_accessor :icon_index
 
 #--------------------------------------------------------------------------
 # common cache: load_notetags_cs
 #--------------------------------------------------------------------------
 def load_notetags_cs
   @icon_index = 0
   @help_description_on = false
   #---
   self.note.split(/[\r\n]+/).each { |line|
     case line
     #---
     when YEA::REGEXP::CLASS::ICON_INDEX
       @icon_index = $1.to_i
     #---
     when YEA::REGEXP::CLASS::HELP_DESCRIPTION_ON
       @help_description_on = true
     when YEA::REGEXP::CLASS::HELP_DESCRIPTION_OFF
       @help_description_on = false
     #---
     else
       @description += line.to_s if @help_description_on
     end
   } # self.note.split
   #---
   @description.gsub!(/[|]/i) { "\n" }
 end
 
end # RPG::Class

#==============================================================================
# ■ Game_Temp
#==============================================================================

class Game_Temp
 
 #--------------------------------------------------------------------------
 # public instance variables
 #--------------------------------------------------------------------------
 attr_accessor :scene_class_index
 attr_accessor :scene_class_oy
 
end # Game_Temp

#==============================================================================
# ■ Game_Action
#==============================================================================

class Game_Action
 
 #--------------------------------------------------------------------------
 # alias method: valid?
 #--------------------------------------------------------------------------
 alias game_action_valid_cs valid?
 def valid?
   return false if check_auto_battle_class
   return game_action_valid_cs
 end
 
 #--------------------------------------------------------------------------
 # new method: check_auto_battle_class
 #--------------------------------------------------------------------------
 def check_auto_battle_class
   return false unless subject.actor?
   return false unless subject.auto_battle?
   return false if item.nil?
   return false if subject.added_skill_types.include?(item.stype_id)
   return false if item.id == subject.attack_skill_id
   return true
 end
 
end # Game_Action

#==============================================================================
# ■ Game_BattlerBase
#==============================================================================

class Game_BattlerBase
 
 #--------------------------------------------------------------------------
 # public instance variables
 #--------------------------------------------------------------------------
 attr_accessor :temp_flag
 
 #--------------------------------------------------------------------------
 # alias method: added_skill_types
 #--------------------------------------------------------------------------
 alias game_battlerbase_added_skill_types_cs added_skill_types
 def added_skill_types
   result = game_battlerbase_added_skill_types_cs
   result |= subclass_skill_types
   return result
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_skill_types
 #--------------------------------------------------------------------------
 def subclass_skill_types; return []; end
 
 #--------------------------------------------------------------------------
 # alias method: equip_wtype_ok?
 #--------------------------------------------------------------------------
 alias game_battlerbase_equip_wtype_ok_cs equip_wtype_ok?
 def equip_wtype_ok?(wtype_id)
   return true if subclass_equip_wtype?(wtype_id)
   return game_battlerbase_equip_wtype_ok_cs(wtype_id)
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_equip_wtype?
 #--------------------------------------------------------------------------
 def subclass_equip_wtype?(wtype_id); return false; end
 
 #--------------------------------------------------------------------------
 # alias method: equip_atype_ok?
 #--------------------------------------------------------------------------
 alias game_battlerbase_equip_atype_ok_cs equip_atype_ok?
 def equip_atype_ok?(atype_id)
   return true if subclass_equip_atype?(atype_id)
   return game_battlerbase_equip_atype_ok_cs(atype_id)
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_equip_atype?
 #--------------------------------------------------------------------------
 def subclass_equip_atype?(atype_id); return false; end
 
end # Game_BattlerBase

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
 
 #--------------------------------------------------------------------------
 # alias method: setup
 #--------------------------------------------------------------------------
 alias game_actor_setup_cs setup
 def setup(actor_id)
   game_actor_setup_cs(actor_id)
   init_unlocked_classes
   init_subclass
 end
 
 #--------------------------------------------------------------------------
 # new method: init_unlocked_classes
 #--------------------------------------------------------------------------
 def init_unlocked_classes
   @unlocked_classes = actor.unlocked_classes.clone
   @unlocked_classes.push(@class_id) if !@unlocked_classes.include?(@class_id)
   @unlocked_classes.sort!
 end
 
 #--------------------------------------------------------------------------
 # new method: init_subclass
 #--------------------------------------------------------------------------
 def init_subclass
   @subclass_id = 0
 end
 
 #--------------------------------------------------------------------------
 # new method: unlocked_classes
 #--------------------------------------------------------------------------
 def unlocked_classes
   init_unlocked_classes if @unlocked_classes.nil?
   return @unlocked_classes
 end
 
 #--------------------------------------------------------------------------
 # new method: unlock_class
 #--------------------------------------------------------------------------
 def unlock_class(class_id)
   init_unlocked_classes if @unlocked_classes.nil?
   return if @unlocked_classes.include?(class_id)
   @unlocked_classes.push(class_id)
   learn_class_skills(class_id)
 end
 
 #--------------------------------------------------------------------------
 # new method: remove_class
 #--------------------------------------------------------------------------
 def remove_class(class_id)
   init_unlocked_classes if @unlocked_classes.nil?
   return if class_id == @class_id
   @unlocked_classes.delete(class_id)
   @subclass_id = 0 if class_id == @subclass_id
   refresh
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass
 #--------------------------------------------------------------------------
 def subclass
   init_subclass if @subclass_id.nil?
   return $data_classes[@subclass_id]
 end
 
 #--------------------------------------------------------------------------
 # alias method: change_class
 #--------------------------------------------------------------------------
 alias game_actor_change_class_cs change_class
 def change_class(class_id, keep_exp = false)
   @subclass_id = 0 if @subclass_id == class_id
   game_actor_change_class_cs(class_id, keep_exp)
   learn_class_skills(class_id)
   unlock_class(class_id)
 end
 
 #--------------------------------------------------------------------------
 # new method: learn_class_skills
 #--------------------------------------------------------------------------
 def learn_class_skills(class_id)
   return if class_id <= 0
   return if $data_classes[class_id].nil?
   $data_classes[class_id].learnings.each do |learning|
     learn_skill(learning.skill_id) if learning.level == class_level(class_id)
   end
 end
 
 #--------------------------------------------------------------------------
 # new method: change_subclass
 #--------------------------------------------------------------------------
 def change_subclass(class_id)
   return if class_id == @class_id
   unlock_class(class_id)
   @subclass_id = @subclass_id == class_id ? 0 : class_id
   learn_class_skills(@subclass_id)
   refresh
 end
 
 #--------------------------------------------------------------------------
 # new method: class_level
 #--------------------------------------------------------------------------
 def class_level(class_id)
   return @level if YEA::CLASS_SYSTEM::MAINTAIN_LEVELS
   temp_class = $data_classes[class_id]
   @exp[class_id] = 0 if @exp[class_id].nil?
   n = 1
   loop do
     break if temp_class.exp_for_level(n+1) > @exp[class_id]
     n += 1
   end
   return n
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_level
 #--------------------------------------------------------------------------
 def subclass_level
   return 0 if @subclass_id == 0
   return @level if YEA::CLASS_SYSTEM::MAINTAIN_LEVELS
   return class_level(@subclass_id)
 end
 
 #--------------------------------------------------------------------------
 # alias method: param_base
 #--------------------------------------------------------------------------
 alias game_actor_param_base_cs param_base
 def param_base(param_id)
   result = game_actor_param_base_cs(param_id)
   unless subclass.nil?
     subclass_rate = YEA::CLASS_SYSTEM::SUBCLASS_STAT_RATE
     slevel = subclass_level
     result += subclass.params[param_id, slevel] * subclass_rate
   end
   return result.to_i
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_skill_types
 #--------------------------------------------------------------------------
 def subclass_skill_types
   return [] unless YEA::CLASS_SYSTEM::SUBCLASS_SKILL_TYPES
   return [] if subclass.nil?
   array = []
   for feature in subclass.features
     next unless feature.code == FEATURE_STYPE_ADD
     next if features_set(FEATURE_STYPE_ADD).include?(feature.data_id)
     array.push(feature.data_id)
   end
   return array
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_equip_wtype?
 #--------------------------------------------------------------------------
 def subclass_equip_wtype?(wtype_id)
   return false unless YEA::CLASS_SYSTEM::SUBCLASS_WEAPON_TYPES
   return false if subclass.nil?
   for feature in subclass.features
     next unless feature.code == FEATURE_EQUIP_WTYPE
     return true if wtype_id == feature.data_id
   end
   return super
 end
 
 #--------------------------------------------------------------------------
 # new method: subclass_equip_atype?
 #--------------------------------------------------------------------------
 def subclass_equip_atype?(atype_id)
   return false unless YEA::CLASS_SYSTEM::SUBCLASS_ARMOUR_TYPES
   return false if subclass.nil?
   for feature in subclass.features
     next unless feature.code == FEATURE_EQUIP_ATYPE
     return true if atype_id == feature.data_id
   end
   return super
 end
 
 #--------------------------------------------------------------------------
 # alias method: release_unequippable_items
 #--------------------------------------------------------------------------
 alias game_actor_release_unequippable_items_cs release_unequippable_items
 def release_unequippable_items(item_gain = true)
   item_gain = false if @temp_flag
   game_actor_release_unequippable_items_cs(item_gain)
 end
 
end # Game_Actor

#==============================================================================
# ■ Game_Interpreter
#==============================================================================

class Game_Interpreter
 
 #--------------------------------------------------------------------------
 # overwrite method: command_321
 #--------------------------------------------------------------------------
 def command_321
   actor = $game_actors[@params[0]]
   if actor && $data_classes[@params[1]]
     maintain = YEA::CLASS_SYSTEM::MAINTAIN_LEVELS
     actor.change_class(@params[1], maintain)
   end
 end
 
end # Game_Interpreter

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
 
 #--------------------------------------------------------------------------
 # overwrite method: draw_actor_class
 #--------------------------------------------------------------------------
 def draw_actor_class(actor, x, y, width = 112)
   change_color(normal_color)
   if actor.subclass.nil?
     text = actor.class.name
   else
     fmt = YEA::CLASS_SYSTEM::SUBCLASS_TEXT
     text = sprintf(fmt, actor.class.name, actor.subclass.name)
   end
   draw_text(x, y, width, line_height, text)
 end
 
end # Window_Base

#==============================================================================
# ■ Window_MenuCommand
#==============================================================================

class Window_MenuCommand < Window_Command
 
 #--------------------------------------------------------------------------
 # alias method: add_formation_command
 #--------------------------------------------------------------------------
 alias window_menucommand_add_formation_command_cs add_formation_command
 def add_formation_command
   add_class_command unless $imported["YEA-AceMenuEngine"]
   window_menucommand_add_formation_command_cs
 end
 
 #--------------------------------------------------------------------------
 # new method: add_class_command
 #--------------------------------------------------------------------------
 def add_class_command
   return unless Switch.class_show
   text = YEA::CLASS_SYSTEM::CLASS_MENU_TEXT
   add_command(text, :class, Switch.class_enable)
 end
 
end # Window_MenuCommand

#==============================================================================
# ■ Window_ClassCommand
#==============================================================================

class Window_ClassCommand < Window_Command
 
 #--------------------------------------------------------------------------
 # initialize
 #--------------------------------------------------------------------------
 def initialize(x, y)
   super(x, y)
   @actor = nil
 end
 
 #--------------------------------------------------------------------------
 # ● ウィンドウ幅の取得
 #--------------------------------------------------------------------------
 def window_width; return 160; end
 
 #--------------------------------------------------------------------------
 # actor=
 #--------------------------------------------------------------------------
 def actor=(actor)
   return if @actor == actor
   @actor = actor
   refresh
 end
 
 #--------------------------------------------------------------------------
 # item_window=
 #--------------------------------------------------------------------------
 def item_window=(window)
   @item_window = window
 end
 
 #--------------------------------------------------------------------------
 # visible_line_number
 #--------------------------------------------------------------------------
 def visible_line_number; return 4; end
 
 #--------------------------------------------------------------------------
 # make_command_list
 #--------------------------------------------------------------------------
 def make_command_list
   return if @actor.nil?
   for command in YEA::CLASS_SYSTEM::COMMANDS
     case command[0]
     when :primary
       next unless Switch.primary_show
       add_command(command[1], command[0], Switch.primary_enable)
     when :subclass
       next unless Switch.subclass_show
       add_command(command[1], command[0], Switch.subclass_enable)
     when :learn_skill
       next unless $imported["YEA-LearnSkillEngine"]
       add_learn_skill_command
     else
       process_custom_command(command)
     end
   end
   if !$game_temp.scene_class_index.nil?
     select($game_temp.scene_class_index)
     self.oy = $game_temp.scene_class_oy
   end
   $game_temp.scene_class_index = nil
   $game_temp.scene_class_oy = nil
 end
 
 #--------------------------------------------------------------------------
 # process_ok
 #--------------------------------------------------------------------------
 def process_ok
   $game_temp.scene_class_index = index
   $game_temp.scene_class_oy = self.oy
   super
 end
 
 #--------------------------------------------------------------------------
 # process_custom_command
 #--------------------------------------------------------------------------
 def process_custom_command(command)
   return unless YEA::CLASS_SYSTEM::CUSTOM_CLASS_COMMANDS.include?(command[0])
   show = YEA::CLASS_SYSTEM::CUSTOM_CLASS_COMMANDS[command[0]][1]
   continue = show <= 0 ? true : $game_switches[show]
   return unless continue
   text = command[1]
   switch = YEA::CLASS_SYSTEM::CUSTOM_CLASS_COMMANDS[command[0]][0]
   enabled = switch <= 0 ? true : $game_switches[switch]
   add_command(text, command[0], enabled)
 end
 
 #--------------------------------------------------------------------------
 # update
 #--------------------------------------------------------------------------
 def update
   super
   update_visible_windows
 end
 
 #--------------------------------------------------------------------------
 # update_visible_windows
 #--------------------------------------------------------------------------
 def update_visible_windows
   return if @current_index == current_symbol
   @current_index = current_symbol
   @item_window.refresh unless @item_window.nil?
 end
 
 #--------------------------------------------------------------------------
 # add_learn_skill_command
 #--------------------------------------------------------------------------
 def add_learn_skill_command
   return unless Switch.show_learn_skill
   name = YEA::LEARN_SKILL::COMMAND_NAME
   add_command(name, :learn_skill, true)
 end
 
end # Window_ClassCommand

#==============================================================================
# ■ Window_ClassStatus
#==============================================================================

class Window_ClassStatus < Window_Base
 
 #--------------------------------------------------------------------------
 # initialize
 #--------------------------------------------------------------------------
 def initialize(dx, dy)
   super(dx, dy, window_width, fitting_height(4))
   @actor = nil
 end
 
 #--------------------------------------------------------------------------
 # window_width
 #--------------------------------------------------------------------------
 def window_width; Graphics.width - 160; end
 
 #--------------------------------------------------------------------------
 # actor=
 #--------------------------------------------------------------------------
 def actor=(actor)
   return if @actor == actor
   @actor = actor
   refresh
 end
 
 #--------------------------------------------------------------------------
 # refresh
 #--------------------------------------------------------------------------
 def refresh
   contents.clear
   return if @actor.nil?
   draw_actor_face(@actor, 0, 0)
   draw_actor_simple_status(@actor, 108, line_height / 2)
 end
 
end # Window_ClassStatus

#==============================================================================
# ■ Window_ClassParam
#==============================================================================

class Window_ClassParam < Window_Base
 
 #--------------------------------------------------------------------------
 # initialize
 #--------------------------------------------------------------------------
 def initialize(dx, dy)
   super(dx, dy, window_width, Graphics.height - dy)
   @actor = nil
   @temp_actor = nil
   refresh
 end
 
 #--------------------------------------------------------------------------
 # window_width
 #--------------------------------------------------------------------------
 def window_width; return Graphics.width * 2 / 5; end
 
 #--------------------------------------------------------------------------
 # actor=
 #--------------------------------------------------------------------------
 def actor=(actor)
   return if @actor == actor
   @actor = actor
   refresh
 end
 
 #--------------------------------------------------------------------------
 # refresh
 #--------------------------------------------------------------------------
 def refresh
   contents.clear
   8.times {|i| draw_item(0, line_height * i, i) }
 end
 
 #--------------------------------------------------------------------------
 # set_temp_actor
 #--------------------------------------------------------------------------
 def set_temp_actor(temp_actor)
   return if @temp_actor == temp_actor
   @temp_actor = temp_actor
   refresh
 end
 
 #--------------------------------------------------------------------------
 # draw_item
 #--------------------------------------------------------------------------
 def draw_item(dx, dy, param_id)
   draw_background_colour(dx, dy)
   draw_param_name(dx + 4, dy, param_id)
   draw_current_param(dx + 4, dy, param_id) if @actor
   drx = (contents.width + 22) / 2
   draw_right_arrow(drx, dy)
   draw_new_param(drx + 22, dy, param_id) if @temp_actor
   reset_font_settings
 end
 
 #--------------------------------------------------------------------------
 # draw_background_colour
 #--------------------------------------------------------------------------
 def draw_background_colour(dx, dy)
   colour = Color.new(0, 0, 0, translucent_alpha/2)
   rect = Rect.new(dx+1, dy+1, contents.width - 2, line_height - 2)
   contents.fill_rect(rect, colour)
 end
 
 #--------------------------------------------------------------------------
 # overwrite method: draw_param_name
 #--------------------------------------------------------------------------
 def draw_param_name(dx, dy, param_id)
   contents.font.size = YEA::CLASS_SYSTEM::PARAM_FONT_SIZE
   change_color(system_color)
   draw_text(dx, dy, contents.width, line_height, Vocab::param(param_id))
 end
 
 #--------------------------------------------------------------------------
 # overwrite method: draw_current_param
 #--------------------------------------------------------------------------
 def draw_current_param(dx, dy, param_id)
   change_color(normal_color)
   dw = (contents.width + 22) / 2
   draw_text(0, dy, dw, line_height, @actor.param(param_id).group, 2)
   reset_font_settings
 end
 
 #--------------------------------------------------------------------------
 # draw_right_arrow
 #--------------------------------------------------------------------------
 def draw_right_arrow(x, y)
   change_color(system_color)
   draw_text(x, y, 22, line_height, "→", 1)
 end
 
 #--------------------------------------------------------------------------
 # draw_new_param
 #--------------------------------------------------------------------------
 def draw_new_param(dx, dy, param_id)
   contents.font.size = YEA::CLASS_SYSTEM::PARAM_FONT_SIZE
   new_value = @temp_actor.param(param_id)
   change_color(param_change_color(new_value - @actor.param(param_id)))
   draw_text(0, dy, contents.width-4, line_height, new_value.group, 2)
   reset_font_settings
 end
 
end # Window_ClassParam

#==============================================================================
# ■ Window_ClassList
#==============================================================================

class Window_ClassList < Window_Selectable
 
 #--------------------------------------------------------------------------
 # initialize
 #--------------------------------------------------------------------------
 def initialize(dx, dy)
   dw = Graphics.width - (Graphics.width * 2 / 5)
   dh = Graphics.height - dy
   super(dx, dy, dw, dh)
   @actor = nil
   @command_window = nil
   @status_window
   @data = []
 end
 
 #--------------------------------------------------------------------------
 # actor=
 #--------------------------------------------------------------------------
 def actor=(actor)
   return if @actor == actor
   @actor = actor
   @last_item = nil
   refresh
   self.oy = 0
 end
 
 #--------------------------------------------------------------------------
 # command_window=
 #--------------------------------------------------------------------------
 def command_window=(command_window)
   @command_window = command_window
 end
 
 #--------------------------------------------------------------------------
 # status_window=
 #--------------------------------------------------------------------------
 def status_window=(status_window)
   @status_window = status_window
 end
 
 #--------------------------------------------------------------------------
 # item_max
 #--------------------------------------------------------------------------
 def item_max; return @data ? @data.size : 1; end
 
 #--------------------------------------------------------------------------
 # item
 #--------------------------------------------------------------------------
 def item; return @data && index >= 0 ? @data[index] : nil; end
 
 #--------------------------------------------------------------------------
 # current_item_enabled?
 #--------------------------------------------------------------------------
 def current_item_enabled?; return enable?(@data[index]); end
 
 #--------------------------------------------------------------------------
 # include?
 #--------------------------------------------------------------------------
 def include?(item)
   return true if YEA::CLASS_SYSTEM::DEFAULT_UNLOCKS.include?(item.id)
   return @actor.unlocked_classes.include?(item.id)
 end
 
 #--------------------------------------------------------------------------
 # enable?
 #--------------------------------------------------------------------------
 def enable?(item)
   return false if item == @actor.class
   return true
 end
 
 #--------------------------------------------------------------------------
 # make_item_list
 #--------------------------------------------------------------------------
 def make_item_list
   @data = []
   for class_id in YEA::CLASS_SYSTEM::CLASS_ORDER
     next if $data_classes[class_id].nil?
     item = $data_classes[class_id]
     @data.push(item) if include?(item)
   end
 end
 
 #--------------------------------------------------------------------------
 # select_last
 #--------------------------------------------------------------------------
 def select_last
   case @command_window.current_symbol
   when :primary
     select(@data.index(@actor.class))
   when :subclass
     select(0) if @actor.subclass.nil?
     select(@data.index(@actor.subclass)) unless @actor.subclass.nil?
   else
     select(0)
   end
 end
 
 #--------------------------------------------------------------------------
 # draw_item
 #--------------------------------------------------------------------------
 def draw_item(index)
   item = @data[index]
   return if item.nil?
   rect = item_rect(index)
   rect.width -= 4
   reset_font_settings
   set_item_colour(item)
   draw_class_icon(item, rect)
   draw_class_name(item, rect)
   draw_class_level(item, rect)
 end
 
 #--------------------------------------------------------------------------
 # set_item_colour
 #--------------------------------------------------------------------------
 def set_item_colour(item)
   if item == @actor.class
     change_color(text_color(YEA::CLASS_SYSTEM::CURRENT_CLASS_COLOUR))
   elsif item == @actor.subclass
     change_color(text_color(YEA::CLASS_SYSTEM::SUBCLASS_COLOUR))
   else
     change_color(normal_color, enable?(item))
   end
 end
 
 #--------------------------------------------------------------------------
 # draw_class_icon
 #--------------------------------------------------------------------------
 def draw_class_icon(item, rect)
   icon = item.icon_index
   draw_icon(icon, rect.x, rect.y, enable?(item))
 end
 
 #--------------------------------------------------------------------------
 # draw_class_name
 #--------------------------------------------------------------------------
 def draw_class_name(item, rect)
   text = item.name
   draw_text(24, rect.y, rect.width-24, line_height, text)
 end
 
 #--------------------------------------------------------------------------
 # draw_class_level
 #--------------------------------------------------------------------------
 def draw_class_level(item, rect)
   return if YEA::CLASS_SYSTEM::MAINTAIN_LEVELS
   return if @actor.nil?
   level = @actor.class_level(item.id)
   contents.font.size = YEA::CLASS_SYSTEM::LEVEL_FONT_SIZE
   text = sprintf(YEA::CLASS_SYSTEM::CLASS_LEVEL, level.group)
   draw_text(rect, text, 2)
 end
 
 #--------------------------------------------------------------------------
 # update_help
 #--------------------------------------------------------------------------
 def update_help
   @help_window.set_item(item)
   return if @actor.nil?
   return if @status_window.nil?
   update_param_window
 end
 
 #--------------------------------------------------------------------------
 # update_param_window
 #--------------------------------------------------------------------------
 def update_param_window
   return if @last_item == item
   @last_item = item
   class_id = item.nil? ? @actor.class_id : item.id
   temp_actor = Marshal.load(Marshal.dump(@actor))
   temp_actor.temp_flag = true
   case @command_window.current_symbol
   when :primary
     temp_actor.change_class(class_id, YEA::CLASS_SYSTEM::MAINTAIN_LEVELS)
   when :subclass
     temp_actor.change_subclass(class_id)
   end
   @status_window.set_temp_actor(temp_actor)
 end
 
 #--------------------------------------------------------------------------
 # update_class
 #--------------------------------------------------------------------------
 def update_class
   @last_item = nil
   update_help
   refresh
   activate
 end
 
 #--------------------------------------------------------------------------
 # refresh
 #--------------------------------------------------------------------------
 def refresh
   make_item_list
   create_contents
   draw_all_items
 end
 
end # Window_ClassList

#==============================================================================
# ■ Scene_Menu
#==============================================================================

class Scene_Menu < Scene_MenuBase
 
 #--------------------------------------------------------------------------
 # alias method: create_command_window
 #--------------------------------------------------------------------------
 alias scene_menu_create_command_window_cs create_command_window
 def create_command_window
   scene_menu_create_command_window_cs
   @command_window.set_handler(:class, method(:command_personal))
 end
 
 #--------------------------------------------------------------------------
 # alias method: on_personal_ok
 #--------------------------------------------------------------------------
 alias scene_menu_on_personal_ok_cs on_personal_ok
 def on_personal_ok
   case @command_window.current_symbol
   when :class
     SceneManager.call(Scene_Class)
   else
     scene_menu_on_personal_ok_cs
   end
 end
 
end # Scene_Menu

#==============================================================================
# ■ Scene_Class
#==============================================================================

class Scene_Class < Scene_MenuBase
 
 #--------------------------------------------------------------------------
 # start
 #--------------------------------------------------------------------------
 def start
   super
   create_help_window
   create_command_window
   create_status_window
   create_param_window
   create_item_window
   relocate_windows
 end
 
 #--------------------------------------------------------------------------
 # create_command_window
 #--------------------------------------------------------------------------
 def create_command_window
   wy = @help_window.height
   @command_window = Window_ClassCommand.new(0, wy)
   @command_window.viewport = @viewport
   @command_window.help_window = @help_window
   @command_window.actor = @actor
   @command_window.set_handler(:cancel,  method(:return_scene))
   @command_window.set_handler(:primary,  method(:command_class_change))
   @command_window.set_handler(:subclass, method(:command_class_change))
   process_custom_class_commands
   return if $game_party.in_battle
   @command_window.set_handler(:pagedown, method(:next_actor))
   @command_window.set_handler(:pageup,  method(:prev_actor))
   @command_window.set_handler(:learn_skill, method(:command_learn_skill))
 end
 
 #--------------------------------------------------------------------------
 # process_custom_class_commands
 #--------------------------------------------------------------------------
 def process_custom_class_commands
   for command in YEA::CLASS_SYSTEM::COMMANDS
     next unless YEA::CLASS_SYSTEM::CUSTOM_CLASS_COMMANDS.include?(command[0])
     called_method = YEA::CLASS_SYSTEM::CUSTOM_CLASS_COMMANDS[command[0]][2]
     @command_window.set_handler(command[0], method(called_method))
   end
 end
 
 #--------------------------------------------------------------------------
 # create_status_window
 #--------------------------------------------------------------------------
 def create_status_window
   wy = @help_window.height
   @status_window = Window_ClassStatus.new(@command_window.width, wy)
   @status_window.viewport = @viewport
   @status_window.actor = @actor
 end
 
 #--------------------------------------------------------------------------
 # create_param_window
 #--------------------------------------------------------------------------
 def create_param_window
   dx = Graphics.width - (Graphics.width * 2 / 5)
   dy = @status_window.y + @status_window.height
   @param_window = Window_ClassParam.new(dx, dy)
   @param_window.viewport = @viewport
   @param_window.actor = @actor
 end
 
 #--------------------------------------------------------------------------
 # create_item_window
 #--------------------------------------------------------------------------
 def create_item_window
   dy = @status_window.y + @status_window.height
   @item_window = Window_ClassList.new(0, dy)
   @item_window.help_window = @help_window
   @item_window.command_window = @command_window
   @item_window.status_window = @param_window
   @item_window.viewport = @viewport
   @item_window.actor = @actor
   @command_window.item_window = @item_window
   @item_window.set_handler(:ok,    method(:on_class_ok))
   @item_window.set_handler(:cancel, method(:on_class_cancel))
 end
 
 #--------------------------------------------------------------------------
 # relocate_windows
 #--------------------------------------------------------------------------
 def relocate_windows
   return unless $imported["YEA-AceMenuEngine"]
   case Menu.help_window_location
   when 0 # Top
     @help_window.y = 0
     @command_window.y = @help_window.height
     @param_window.y = @command_window.y + @command_window.height
   when 1 # Middle
     @command_window.y = 0
     @help_window.y = @command_window.height
     @param_window.y = @help_window.y + @help_window.height
   else # Bottom
     @command_window.y = 0
     @param_window.y = @command_window.height
     @help_window.y = @param_window.y + @param_window.height
   end
   @status_window.y = @command_window.y
   @item_window.y = @param_window.y
 end
 
 #--------------------------------------------------------------------------
 # on_actor_change
 #--------------------------------------------------------------------------
 def on_actor_change
   @command_window.actor = @actor
   @status_window.actor = @actor
   @param_window.actor = @actor
   @item_window.actor = @actor
   @command_window.activate
 end
 
 #--------------------------------------------------------------------------
 # command_class_change
 #--------------------------------------------------------------------------
 def command_class_change
   @item_window.activate
   @item_window.select_last
 end
 
 #--------------------------------------------------------------------------
 # on_class_cancel
 #--------------------------------------------------------------------------
 def on_class_cancel
   @item_window.unselect
   @command_window.activate
   @param_window.set_temp_actor(nil)
 end
 
 #--------------------------------------------------------------------------
 # on_class_ok
 #--------------------------------------------------------------------------
 def on_class_ok
   Sound.play_equip
   class_id = @item_window.item.id
   maintain = YEA::CLASS_SYSTEM::MAINTAIN_LEVELS
   hp = @actor.hp * 1.0 / @actor.mhp
   mp = @actor.mp * 1.0 / [@actor.mmp, 1].max
   case @command_window.current_symbol
   when :primary
     @actor.change_class(class_id, maintain)
   when :subclass
     @actor.change_subclass(class_id)
   else
     @item_window.activate
     return
   end
   @actor.hp = (@actor.mhp * hp).to_i
   @actor.mp = (@actor.mmp * mp).to_i
   @status_window.refresh
   @item_window.update_class
 end
 
 #--------------------------------------------------------------------------
 # new method: command_learn_skill
 #--------------------------------------------------------------------------
 def command_learn_skill
   return unless $imported["YEA-LearnSkillEngine"]
   SceneManager.call(Scene_LearnSkill)
 end
 
 #--------------------------------------------------------------------------
 # command_name1
 #--------------------------------------------------------------------------
 def command_name1
   # Do nothing.
 end
 
 #--------------------------------------------------------------------------
 # command_name2
 #--------------------------------------------------------------------------
 def command_name2
   # Do nothing.
 end
 
end # Scene_Class

#==============================================================================
#
# ▼ End of File
#
#==============================================================================