View difference between Paste ID: KssYN68V and 1xqAjx0E

 #==============================================================================
 #
 # ▼ Yanfly Engine Ace - Class System v1.10
 # -- Last Updated: 2012.12.03
 # -- Level: Normal, Hard
 # -- Requires: n/a
 #
 #==============================================================================
 
 $imported = {} if $imported.nil?
 $imported["YEA-ClassSystem"] = true
 
 #==============================================================================
 # ▼ Updates
 # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 # 2012.12.03 - Added JP after the name of the class, in the class list. By SoundReaper.
 # 2012.08.06 - Leveling issue if class level exceeds actor level.
 # 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.
 # -----------------------------------------------------------------------------
 # <unlocked classes: x>
 # <unlocked classes: x, x>
 # 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.
 # -----------------------------------------------------------------------------
 # <icon: x>
 # Sets the icon representing the class to x.
 #
 # <help description>
 #  string
 #  string
 # </help description>
 # 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 = "Professions"  # Text that appears in the Main Menu.
     MAINTAIN_LEVELS = false    # Maintain through all classes. Default: false.
     DEFAULT_UNLOCKS = []   # 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.20
 
     # 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,   "Principale"],
     # [:subclass,  "Secondaire"],
      [:learn_skill, "Apprentissage"],
     # [ :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,
       :custom1 => [           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     = "Niv.%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 <<self; alias load_database_cs load_database; end
   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 Edited by DisturbedInside
 	#————————————————————————–
 	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?
 			#declare a max level (using EXP)
 			#If you can’t find it, go to the class database and select exp curve
 			#then switch view to total at the top
 			@exp[max_level] = 2547133 #This is the value to change. It declares a max level
 			#You need to calculate how much exp for max level
 			#Do it manually if using Yanfly-Adjusting Limits
 			#To calculate max level exp if using Yanfly-adjusting limits is all math!!
 
 			# Level 99 = 2547133
 			# to calculate past there…. have to add on multiples of 50744
 			# Level 110 = 3156061
 			# To go from 99 -> 110 have to add on 12 multiples of 50744.
 			n = 1
 			loop do
 				break if temp_class.exp_for_level(n+1) > @exp[class_id]
 				n += 1
 				#add a restriction to “kick out” of loop if exp exceeds max level exp
 				break if temp_class.exp_for_level(n+1) > @exp[max_level]
 			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)
     draw_class_jp(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
 
   #--------------------------------------------------------------------------
   # draw_class_jp
   #--------------------------------------------------------------------------
   def draw_class_jp(item, rect)
     return unless $imported["YEA-JPManager"]
     draw_actor_jp_class(@actor, item.id, rect.x+rect.width/2, rect.y)
   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
 #
 #==============================================================================