YEA - Class System Parameters Help — RPG Maker Forum Archive

Sorry, I fell asleep at the computer due to lack of sleep. I'm going to try staying conscious so we can get this situated.

Okay here is how the subclass rate works.

It was set to .20, so I moved it to be set to 1, since that should add the entire thing. However, I did try something that came up with an interesting result. In the formula you gave me, I tried to switch the plus to a minus. And it STILL added it and it STILL didn't divide by the two. Would there be something earlier on in the script preventing this from happening?

Spoiler

#==============================================================================#

# ▼ 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.

# -----------------------------------------------------------------------------

# <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 = "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 = 1



# 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 |=

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 = (game_actor_param_base_cs(param_id) + subclass.params[param_id, slevel]) / 2

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

#

#==============================================================================

I included the entire thing, maybe there's something on a previous line that's changing it to make it do this? You will also see that I included the line that you told me to add in it. Again, sorry for the disappearance.

EDIT: I found this 'Class Extensions' thing, and I wondered if this could be of some help to us, since I saw a really interesting section. Would we be able to use this to get the desired result? I've pasted an image of my findings below.