#============================================================================== # # ▼ Yanfly Engine Ace - Class System v1.10 # -- Last Updated: 2012.01.29 # -- Level: Normal, Hard # -- Requires: n/a # #============================================================================== $imported = {} if $imported.nil? $imported["YEA-ClassSystem"] = true #============================================================================== # ▼ Updates # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= # 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. # ----------------------------------------------------------------------------- # # # 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 # 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 = "Class" # Text that appears in the Main Menu. MAINTAIN_LEVELS = false # Maintain through all classes. Default: false. DEFAULT_UNLOCKS = [ 1, 11, 21, 31] # 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, "Primary"], [:subclass, "Subclass"], [:learn_skill, "Custom"], # [ :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 = "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 < 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) 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 # #==============================================================================