Yanfly Subclass System

#===============================================================================
#
# Yanfly Engine RD - Subclass Selection System
# Last Date Updated: 2009.06.28
# Level: Hard
#
# There's been a lot of scripts where class changing is possible, but I've yet
# to see anything about a subclass system. Although this script allows changing
# primary classes, its main focus is the subclass system. There are many rules
# you may set for your subclass system. You can enable or disable equipment
# sharing amongst classes. You can choose how subclasses affect your base stats
# or not at all. You can determine how skills can be learned via subclass, etc.
#
# CLASS SYSTEM
# Classes are now split between primary and secondary classes. You can set many
# different rules for each class here inside the script. Secondary classes will
# expand the skill pool and equipment pool an actor has. With the class system,
# actors can also get a change in their base stats depending on which class they
# have equipped at the time. They can also get different amounts of boosts for
# their stats upon leveling up. The possibilities are vast.
#
# JP SYSTEM
# There is a new stat for each actor called JP. This new stat can be earned
# through various ways. It can be earned in battle, from items, attacking, using
# skills and items, and guarding. All of that can be modified. What JP does is
# allow your actors to learn new skills through a JP purchase system. These
# skills are unlocked when JP is spent on them and an actor will permanently
# have the skill at their disposal.
#
# UNLOCK SYSTEM
# Classes are unlocked via directly class changing, items, or learning specific
# skills. Scripted events can also directly unlock classes for actors if that's
# what floats your boat. There is no direct tier system implemented with this
# script since there is too many different ways people would love to have their
# classes unlock and whatnot.
#
#===============================================================================
# Updates:
# ----------------------------------------------------------------------------
# o 2009.06.28 - Added ALLOW_WEAPON and ALLOW_ARMOUR.
# o 2009.05.26 - Compatibility with Scene Status ReDux
# o 2009.05.17 - Small bugfix to the change actor graphics commands.
# o 2009.05.16 - Upgrade Pack 2:
#                Primary-Only Classes and Subclass-Only Classes implemented.
#                Search for PRIMARY_ONLY_CLASSES and SUBCLASS_ONLY_CLASSES
#                Classes can now have special traits.
#                Actors can now change graphics when changing primary classes.
#                Can now event call the menus using the following:
#                $scene = Scene_Class_Change.new
#                $scene = Scene_Learn_Skill.new
#                Anti-crash methods updated.
# o 2009.05.10 - Upgrade Pack 1:
#                Even more lag reduction.
#                Added level requirements and skill requirements.
#                Added Actor-Specific Common Skills Options
#                Added Primary-Class Only Skills Options
#                Added Subclass Only Skills Options
#                Added percentile growth rates dependent on primary and subclass
#                Added Actor-Restricted Classes Options
#                Added Primary/Subclass Stat Rate Percentage Options
#                Added two states that affect JP gain rate.
#                Added mechanic: Learning certain skills can unlock classes.
#                Fixed a few bugs regarding HP/MP during class changing.
# o 2009.05.08 - Compatibility update with YERD Equip Skill Slots.
# o 2009.05.07 - Lag Reduction. Ironed out crashes if people didn't input their
#                class data in correctly.
# o 2009.05.05 - Finished demo. Fix up remaining bugs.
# o 2009.04.30 - Finished script. Started creating demo.
# o 2009.04.29 - Started script.
#===============================================================================
# How to Use: Hard Mode
#===============================================================================
#
# I'm going to label all of this script as hard mode and above for multiple
# reasons. This script is not meant to be taken lightly nor does it provide the
# comfort of regular plug and playing that scripts with normal mode offer. I
# made as much of the script to be plug and play as possible but it will still
# require you to modify your classes properly before this skill will work the
# way you would want it to. After all, this is your game.
#
# ----------------------------------------------------------------------------
#
# Here are some tags you can put into your skills' noteboxes to give them JP
# related effects. Note that if you're not using the JP system at all, you can
# just flat out ignore most of these.
#
# <unlock class x>
# If a skill is learned with this tag, it will unlock class x for the character.
# Input multiple of these tags to unlock multiple classes. The lock class tag
# is not included due to potential save corruption and crashes.
#
# <require level x>
# The actor must be at least x level before they can buy the skill with JP.
#
# <require skill x>
# The actor must know skill x before they can buy the skill with JP. Insert
# multiple of these tags to increase the amount of skills required.
#
# <jp cost x>
# The skill will cost x jp for the actor to learn it.
#
# <jp boost set x>
# If an actor uses this skill, that actor will gain x set amount of JP.
#
# <jp boost ran x>
# If an actor uses this skill, that actor will gain x random amount of JP.
#
# ----------------------------------------------------------------------------
#
# Here are some tags you can put into your items' noteboxes to give them new
# effects. These include JP effects but not all of them. Use accordingly.
#
# <gain jp x>
# The item will give the target ally JP of x amount. JP is given to whatever
# the ally's current class is.
#
# <unlock class x>
# The item will unlock class x for the target ally. Use multiple of these tags
# if you want an item to unlock more than one class.
#
# <lock class x>
# The item will lock class x for the target ally. Use multiple of these tags if
# you want an item to lock more than one class. Unlike the skill counterpart,
# this will not corrupt the save file nor crash the game.
#
# <set primary x> <set subclass x>
# This item will cause the target character to change primary or subclass to
# whatever class x is. If subclass is set to 0, it'll remove the subclass.
#
# ----------------------------------------------------------------------------
#
# There's not much for enemy tags but here it is.
#
# <enemy jp x>
# This determines the amount of JP given by that enemy. If nothing is determined
# by this set value and you allow your enemies to give JP, then the JP delivered
# will equal to the ENEMIES_DEFAULT amount.
#
# ----------------------------------------------------------------------------
#
# There's also not much for state tags but here they are.
#
# <bonus jp per x>
# JP gain rate is x%. If x is 200, then the JP gain rate is 200%.
#
# <bonus jp set x>
# x is added to JP gain. This means if JP gain is 20 and x is 10, total is 30.
#
#===============================================================================
#
# Compatibility
# - Works With: KGC HelpExtension, EquipExtension, CustomMenuCommand
# - Works With: Yanfly Display Skill Query, Equip Skill Slots
# - Alias: Game_Battler: attack_effect, skill_effect, item_effect, item_test
# - Alias: Game_Actor: setup, class_id=, equippable?, level_up, skills, base_*
# - Alias: Game_Actor: a lot of special traits
# - Alias: Scene_Battle: process_battle_start, execute_action_guard
# - Alias: Scene_Battle: display_exp_and_gold
# - Alias: Scene_Menu: create_command_window, update_command_selection,
# - Alias: Scene_Menu: update_actor_selection
# - Alias: Scene_Title: create_game_objects
# - Overwrites: Window_Base: draw_actor_class
#
#===============================================================================
# Credits:
# KGC for Window_Command imports.
#===============================================================================

$imported = {} if $imported == nil
$imported["SubclassSelectionSystem"] = true

module YE
  module SUBCLASS

    #---------------------------------------------------------------------------
    # CLASS SYSTEM
    #---------------------------------------------------------------------------

    # This part sets a bunch of rules regarding subclasses. Each one will allow
    # you to designate how you would like the subclass system rules to flow.
    # Read each part carefully since this will affect how the subclass system
    # will work for YOUR game.

    #---This allows actors to be able to wear equipment that is otherwise only
      # available for their equipped subclass. Set ALLOW_WEAPON to determine
      # whether or not characters can equip their subclass weapons. Set
      # ALLOW_ARMOUR to determine whether characters can equip subclass armours.
      ALLOW_EQUIP = true
      ALLOW_WEAPON = true
      ALLOW_ARMOUR = false

    #---These are two important switches for your game. If they are enabled,
      # their respective options will allow actors to switch their primary class
      # or their subclass. If not, the option to change them will not appear.
      ALLOW_CHANGE_PRIMARY_SWITCH = 70
      ALLOW_CHANGE_SUBCLASS_SWITCH = 71

    #---These are two important switches for your game. If they are enabled,
      # their respective options will appear in the menu. If not, they'll be
      # skipped.
      ENABLE_CLASS_CHANGE_SWITCH = 72
      ENABLE_LEARN_SKILLS_SWITCH = 73

    # This part affects all of the text you see inside the Class Change Menu.
    # Changing OPTION will enable/disable it inside your menu. Everything else
    # will adjust the text that appears.
    MENU_CLASS_CHANGE_OPTION = true
    MENU_CLASS_CHANGE_TITLE = "Class Change"
    MENU_CLASS_CHANGE_PRIM  = "Primary"
    MENU_CLASS_CHANGE_SUB   = "Subclass"
    MENU_CLASS_CHANGE_LEARN = "Learn"
    MENU_CLASS_CHANGE_DONE  = "Finish"
    MENU_CLASS_CHANGE_PARAM = ["MaxHP", "MaxMP", "ATK", "DEF", "SPI", "AGI"]
    MENU_CLASS_CHANGE_ICONS = [     99,     100,     2,    52,    21,    48]

    # This adjusts how the stats and arrows will appear.
    MENU_CLASS_CHANGE_USE_ICON = false
    MENU_CLASS_CHANGE_ARROW    = ">"
    MENU_CLASS_CHANGE_ICON     = 142

    # This affects the display type for new stats.
    # Type 1 - Shows the new stat itself.
    # Type 2 - Shows the increase/decrease in the stat.
    MENU_CLASS_CHANGE_SDISPLAY = 1

    # This allows you to designate icons for your classes. These will show up
    # whenever the class name is drawn.
    CLASS_ICONS ={
    # Class.ID => Icon ID
            0  =>  176,  # Nil Class
            1  =>  667,   # Librarian
            2  =>  43,    # Mage
            3  =>  850,  # Fencer
            4  =>  9,  # Iaido Master
            5  =>  1210,    # Gunslinger
            6  =>  128,  # Cleric
            7  =>  119,  # Arch-Mage
            8  =>  75,   # Shaman
    } # Do not remove this.

    #---This determines how the class and subclass is displayed inside menus.
      DISPLAY_FORMAT = "%s/%s"

    # This allows you to set how the class abbreviations will be displayed
    # in windows that will display the class abbreviations over the full name.
    CLASS_ABBREVIATIONS ={
    # Class.ID => Icon ID
            0  =>  "",    # Nil Class
            1  =>  "Lib",  # Librarian
            2  =>  "Ma",  # Mage
            3  =>  "Fe",  # Fencer
            4  =>  "Ia",  # Iaido Master
            5  =>  "Gu",  # Gunslinger
            6  =>  "Cl",  # Cleric
            7  =>  "Ar",  # Arch-Mage
            8  =>  "Sh",  # Shaman
    } # Do not remove this.

    #---This allows you to set complex class names if your classes managed to
      # meet a specific combination. Take into consideration the slashes if
      # those are used in your display format.
      USE_COMPLEX_CLASS_NAMES = true

    # This is the string transformation data for full complex class naming.
    # Make sure you match it with the display format in order for it to change.
    COMPLEX_CLASS_NAMES_FULL ={
      # Combination Required => New Class Name
           "Mage/Fencer" => "Mystic Duelist",
           "Mage/Iaido Master" => "Rune Blade",
           "Mage/Gunslinger" => "Spell Gun",
           "Mage/Cleric" => "Enchanted Priestess",
           "Mage/Arch-Mage" => "Sorceress",
           "Mage/Shaman" => "Oracle",
           "Fencer/Iaido Master" => "Sword Master",
           "Fencer/Gunslinger" => "Assassin",
           "Fencer/Cleric" => "Divine Duelist",
           "Fencer/Arch-Mage" => "Spellblade",
           "Fencer/Shaman" => "Siren",
           "Iaido Master/Gunslinger" => "Weapon Master",
           "Iaido Master/Cleric" => "Paladin",
           "Iaido Master/Arch-Mage" => "Mana Blade",
           "Iaido Master/Shaman" => "Templar",
           "Gunslinger/Cleric" => "Battlefield Medic",
           "Gunslinger/Arch-Mage" => "Gun Mage",
           "Gunslinger/Shaman" => "Witch Hunter",
           "Cleric/Arch-Mage" => "War Priestess",
           "Cleric/Shaman" => "Druidess",
           "Arch-Mage/Shaman" => "Witch",
    } # Do not remove this.

    # This is the string transformation data for abbreviated complex classes.
    # Make sure you match it with the display format in order for it to change.
    COMPLEX_CLASS_NAMES_ABBR ={
      # Combination Required => New Class Name
                     "Ma/Fe" => "MD",
                     "Ma/Ia" => "RB",
                     "Ma/Gu" => "SG",
                     "Ma/Cl" => "EP",
                     "Ma/Ar" => "So",
                     "Ma/Sh" => "Or",
                     "Fe/Ia" => "SM",
                     "Fe/Gu" => "As",
                     "Fe/Cl" => "DD",
                     "Fe/Ar" => "Sp",
                     "Fe/Sh" => "Si",
                     "Ia/Gu" => "WM",
                     "Ia/Cl" => "Pa",
                     "Ia/Ar" => "MB",
                     "Ia/Sh" => "Te",
                     "Gu/Cl" => "BM",
                     "Gu/Ar" => "GM",
                     "Gu/Sh" => "WH",
                     "Cl/Ar" => "WP",
                     "Cl/Sh" => "Dr",
                     "Ar/Sh" => "Wi",
    } # Do not remove this.

    #---These two options can set some classes to be equippable only as primary
      # or subclass. A primary-only class cannot be equipped as a subclass and
      # vice versa. If a class is in both, it can't be equipped at all unless
      # through force scripted or evented means.
    PRIMARY_ONLY_CLASSES  = []
    SUBCLASS_ONLY_CLASSES = []

    #---This part determines whether or not some actors are restricted to only
      # a certain set of classes. If they're not on this list, those actors will
      # have access to all classes. There is no example shown in the demo.
    ACTOR_RESTRICTED_CLASSES ={
    # ActorID => [Class ID's]
            1 => [1, 2, 3, 4, 5, 6, 7, 8],
            2 => [9],
            3 => [10],
            4 => [11],
            5 => [12],
            6 => [13],
    } # Do not remove this.

    #---This allows actors to instantly learn their subclasses skills if they
      # meet the level requirements upon leveling up or simply changing classes.
      ALLOW_RETRO_LEARN = false

    # This allows you to set which classes allow the actor to use which skills.
    # Even if the actors have learned skills outside of their class/subclass,
    # they won't be able to use them unless the actors equipped those classes.
    # Class 0 designates common skills allowed for all classes.
    CLASS_SKILL_ALLOW ={
    # ClassID => [Skill ID's]
            0 => [],
            1 => [],
            2 => [1, 4, 5],
            3 => [],
            4 => [],
            5 => [],
            6 => [],
            7 => [],
            8 => [],
    } # Do not remove this.

    #---This part determines actor-based common skills. In other words, these
      # skills will always be available for specific actors no matter what
      # primary class or subclass they have equipped
    ACTOR_COMMON_SKILLS ={
    # ActorID => [Skill ID's]
            1 => [1, 4, 5],
            2 => [],
            3 => [],
            4 => [],
            5 => [],
            6 => [],
    } # Do not remove this.

    #---This part determines primary-class only skills. These skills will only
      # be available if the actor has the specific class equipped as primary.
    PRIMARY_ONLY_SKILLS ={
    # ClassID => [Skill ID's]
            1 => [],
            2 => [],
            3 => [],
            4 => [],
            5 => [],
            6 => [],
            7 => [],
            8 => [],
    } # Do not remove this.

    #---This part determines subclass only skills. These skills will only
      # be available if the actor has the specific class equipped as a subclass.
      # There is no example of this shown in the demo.
    SUBCLASS_ONLY_SKILLS ={
    # ClassID => [Skill ID's]
            1 => [],
    } # Do not remove this.

    #---This determines whether or not actor stats are affected by their what
      # class they have equipped. You can also change whether or not subclasses
      # will affect the character's base stats at all.
      AFFECT_STATS_PRIMARY  = true
      AFFECT_STATS_SUBCLASS = true

    # This adjusts how classes affect the actor's stats.
    CLASS_STAT_RATE ={
    # Class.ID => [MaxHP, MaxMP,   ATK,   DEF,   SPI,   AGI]
             0 => [100,   100,     100,   100,   100,   100],
             1 => [1,     1,       1,     1,     1,     1],
             2 => [100,   100,     100,   100,   100,   100],
             3 => [   90,   110,    80,    80,   110,    80],
             4 => [   85,   120,    70,    75,   120,    85],
             5 => [  115,   110,   100,   100,   110,    90],
             6 => [  120,    90,   115,    75,   115,   100],
             7 => [  125,    70,   125,    80,    70,    80],
             8 => [   80,    80,    85,    70,    80,   150],
    } # Do not remove this.

    # This determines what percentage primary and subclasses affect the class
    # stat rates. Normally, you should leave primary at 100% to avoid problems.
    PRIMARY_STAT_RATE  = 100
    SUBCLASS_STAT_RATE = 50

    #---This determines whether or not actors will gain extra stat bonuses for
      # leveling with a specific class. You can decide if their primary class
      # will get the stat bonuses, the subclass getting the bonuses, or both.
      LEVEL_UP_BONUS_PRIMARY  = true
      LEVEL_UP_BONUS_SUBCLASS = true

    # This determines the extra boost in stats actors will get when they level
    # up with that class as their primary or secondary (depending on which is
    # set to true). If a class's ID isn't included here, that class will not
    # get any bonus stats upon level up. Not even class 0.
    CLASS_STAT_BONUS_SET ={
    # Class.ID => [MaxHP, MaxMP,   ATK,   DEF,   SPI,   AGI]
             1 => [   1,     1,      0,     0,     0,     0],
             2 => [   20,     0,     2,     3,     0,     1],
             3 => [    0,    10,     0,     1,     2,     0],
             4 => [    0,    20,     0,     0,     5,     0],
             5 => [    5,     5,     1,     1,     1,     0],
             6 => [    5,     0,     2,     0,     2,     1],
             7 => [   30,     0,     3,     0,     0,     0],
             8 => [    0,     0,     0,     0,     0,     5],
    } # Do not remove this.

    # This also determines the extra boost in stats when actors level up. This
    # is different than the other table in the way that these stats are random
    # increases. This means they can range anywhere from 0 to the numbered
    # amount. You have to enable this growth first.
    BONUS_RANDOM_PRIMARY  = true
    BONUS_RANDOM_SUBCLASS = true
    CLASS_STAT_BONUS_RAN ={
    # Class.ID => [MaxHP, MaxMP,   ATK,   DEF,   SPI,   AGI]
             1 => [    0,     0,     0,     0,     0,     0],
             2 => [    5,     0,     2,     2,     0,     2],
             3 => [    0,     5,     0,     2,     2,     0],
             4 => [    0,     5,     0,     0,     2,     0],
             5 => [    5,     5,     2,     2,     2,     0],
             6 => [    5,     0,     2,     0,     2,     2],
             7 => [    5,     0,     2,     0,     0,     0],
             8 => [    1,     1,     1,     1,     1,     5],
    } # Do not remove this.

    # This determines the percentage growth rate applied depending if it's the
    # primary class or subclass. This affects both set and random increases.
    PRIMARY_GROWTH_RATE  = 100
    SUBCLASS_GROWTH_RATE = 50

    #---------------------------------------------------------------------------
    # CLASS TRAITS
    #---------------------------------------------------------------------------

    # This section governs traits unique to certain classes. These traits are
    # effects you can normally see under the character tab, weapon tag, and
    # armour tag. Traits can be set for primary or subclass. If you want a trait
    # to exist for both, just put it in both hashes.
    #
    # Here is a list of all the traits you can add:
    # "auto battle"   - Actor will automatically attack.
    # "super guard"   - Actor will take even less damage when guarding.
    # "pharmacology"  - Items will have double effect when used by actor.
    # "fast attack"   - Actor will strike quicker when using normals.
    # "dual attack"   - Actor will strike twice when using normals.
    # "prevent crit"  - Critical hits don't work against actor.
    # "half mp cost"  - Actor spends 50% less MP.
    # "double exp"    - Actor gains double the exp.
    # "double jp"     - Actor gains double the jp.
    #
    # "barehanded"    - Actor gains a boost to attack if no weapons equipped.
    # "maxhp up"      - Actor gains a boost to maxhp outside of class rates.
    # "maxmp up"      - Actor gains a boost to maxmp outside of class rates.
    # "atk up"        - Actor gains a boost to atk outside of class rates.
    # "def up"        - Actor gains a boost to def outside of class rates.
    # "spi up"        - Actor gains a boost to spi outside of class rates.
    # "agi up"        - Actor gains a boost to agi outside of class rates.
    #
    # "no weapon"     - Actor cannot use weapon slot.
    # "no shield"     - Actor cannot use shield slot.
    # "no helmet"     - Actor cannot use helmet slot.
    # "no armour"     - Actor cannot use armour slot.
    # "no accessory"  - Actor cannot use accessory slot.
    # "no equips"     - Actor cannot use any equip slot.
    # "all weapon"    - Actor can use all weapons.
    # "all shield"    - Actor can wear all shields.
    # "all helmet"    - Actor can wear all helmets.
    # "all armour"    - Actor can wear all armours.
    # "all accessory" - Actor can wear all accessories.
    # "all equip"     - Actor can wear everything.
    #
    # To give a class more than one trait, separate them by commas.

    # This governs the traits available for classes when equipped as a primary
    # class. If you don't want a class to have a unique primary trait, either
    # remove the entry or keep the array blank.
    PRIMARY_TRAITS_HASH ={
    # Class.ID => [Traits]
             1 => [],
             2 => [],
             3 => [],
             4 => [],
             5 => [],
             6 => [],
             7 => [],
             8 => [],
    } # Do not remove this.

    # This governs the traits available for classes when equipped as a subclass.
    # If you don't want a class to have a unique subclass trait, either remove
    # the entry or keep the array blank.
    SUBCLASS_TRAITS_HASH ={
    # Class.ID => [Traits]
             1 => [],
             2 => [],
             3 => [],
             4 => [],
             5 => [],
             6 => [],
    } # Do not remove this.

    #---------------------------------------------------------------------------
    # CLASS CHANGE GRAPHIC
    #---------------------------------------------------------------------------

    # This array lists which actors will change their graphic upon changing
    # classes. Note that this will only take effect if the primary class is
    # changed and not the subclass. If an actor's ID isn't listed here, that
    # actor's graphic is locked from being able to be changed.
    CHANGE_ACTOR_GRAPHICS = [0]

    # This hash determines which graphics each individual actor will switch to
    # when changing classes. Note that if you don't list an actor ID, the hash
    # will automatically pool the actor together with Actor ID 0. For that
    # reason, do NOT remove actor 0's hash information. If a class ID doesn't
    # appear, the actor will retain its current graphic settings.
    GRAPHIC_HASH ={
    # Actor.ID => Do not remove Actor 0. It's a common pool for unlisted actors.
             0 => [#ClassID, CharName, Ind, FaceName, Ind],
                   [      1, "Actor1",   0, "Actor1",   0],
                   [      2, "Actor1",   2, "Actor1",   2],
                   [      3, "Actor2",   2, "Actor2",   2],
                   [      4, "Actor2",   4, "Actor2",   4],
                   [      5, "Actor1",   4, "Actor1",   4],
                   [      6,   "Evil",   4,   "Evil",   4],
                   [      7, "Actor3",   0, "Actor3",   0],
                   [      8, "Actor3",   2, "Actor3",   2],
                  ],#Next Instance
    } # Do not remove this.

    # These govern the multipliers given to the various traits.
    BAREHAND_MULTIPLIER = 250      # Uses Yanfly Barehand modifier if have.
    MAXHP_MULTIPLIER    = 125      # Additional multiplier regardless of rates.
    MAXMP_MULTIPLIER    = 125      # Additional multiplier regardless of rates.
    ATK_MULTIPLIER      = 150      # Additional multiplier regardless of rates.
    DEF_MULTIPLIER      = 150      # Additional multiplier regardless of rates.
    SPI_MULTIPLIER      = 150      # Additional multiplier regardless of rates.
    AGI_MULTIPLIER      = 150      # Additional multiplier regardless of rates.

    #---------------------------------------------------------------------------
    # JP SYSTEM
    #---------------------------------------------------------------------------

    # The JP system is a system adapted from Final Fantasy Tactics. Your classes
    # will earn JP over battles and can use them to purchase new skills inside a
    # particular menu. This section will allow you to change JP system rules for
    # your game should you desire to use it.
    USE_JP_SYSTEM = true
    MAX_JP_EARNED = 9999
    JP_DEFINITION = "%d JP"
    JP_ICON       = 145

    # This determines whether or not enemies will give JP if killed and the
    # default amount if not set with <enemy jp x>.
    ENEMIES_GIVE_JP   = true
    ENEMIES_SHOW_MSG  = false
    ENEMIES_DEFAULT   = 10
    ENEMIES_MESSAGE   = "%s has earned %s JP from battle."

    # This sets whether or not you'd like your actors to display the JP they've
    # earned in battle (since every action adds JP).
    DISPLAY_ACTOR_JP  = true
    DISPLAY_ACTOR_MSG = "%s gained %d JP this battle."

    # This will determine whether or not the Learn Skill scene can be accessed
    # from the main menu. This also adjusts the text for the scene's options.
    LEARN_SKILL_OPTION = true
    LEARN_SKILL_TITLE  = "Learn Skills"
    LEARN_SKILL_SELECT = "Learn"
    LEARN_SKILL_CHANGE = "Change"
    LEARN_SKILL_DONE   = "Finish"

    # This affects the string data for the status window shown on the side.
    # This also affects what sound effect is played when buying skills.
    LEARN_SKILL_STATUS_HELP = "Select class you would like to learn skills for."
    LEARN_SKILL_STATUS_LEARNED = "%d%% Mastery"
    LEARN_SKILL_STATUS_ALL     = "Mastered!"
    LEARN_SKILL_SHOP_LEARNED   = "Learned"
    LEARN_SKILL_SHOP_STRING    = "%s JP"
    LEARN_SKILL_SHOP_SOUND     = RPG::SE.new("Equip", 80, 100)

    # This is the string data used for required skills and levels before the
    # skill can be purchased with JP.
    REQUIRE_SKILL = "Requires"
    REQUIRE_LEVEL = "Level %d"

    # These icons will replace the JP icon if the class is a primary only skill
    # or a subclass only skill.
    PRIMARY_ONLY_ICON  = 208
    SUBCLASS_ONLY_ICON = 209

    # JP is earned throughout battle from different effects. You can determine
    # what will earn JP here and by how much. Set amounts are the increases that
    # will always occur so long as the action is enabled. Random amounts will
    # increase the JP earned from 0 to that amount.

    EARN_JP_VIA_ATTACK_ENABLE = true         # Normal attacks will earn JP.
    EARN_JP_VIA_ATTACK_AMOUNT = 2           # Earns at least this amount of JP.
    EARN_JP_VIA_ATTACK_RANDOM = 1            # Earns up to this random amount.

    EARN_JP_VIA_SKILL_ENABLE = true          # Skills will earn JP.
    EARN_JP_VIA_SKILL_AMOUNT = 3            # Earns at least this amount of JP.
    EARN_JP_VIA_SKILL_RANDOM = 1            # Earns up to this random amount.

    EARN_JP_VIA_GUARD_ENABLE = true          # Guarding will earn JP.
    EARN_JP_VIA_GUARD_AMOUNT = 2             # Earns at least this amount of JP.
    EARN_JP_VIA_GUARD_RANDOM = 1             # Earns up to this random amount.

    EARN_JP_VIA_ITEMS_ENABLE = true          # Using items will earn JP.
    EARN_JP_VIA_ITEMS_AMOUNT = 2             # Earns at least this amount of JP.
    EARN_JP_VIA_ITEMS_RANDOM = 1             # Earns up to this random amount.

    # This will determine the multipliers for earning JP split between primary
    # and subclasses. This effect is determined every time "gain_jp" definition
    # occurs within the script.

    EARN_JP_MULTIPLIER_PRIMARY  = 100  # Percentage for primary JP earning.
    EARN_JP_MULTIPLIER_SUBCLASS = 50   # Percentage for subclass JP earning.

    #---------------------------------------------------------------------------
    # COMPATIBILITY ADD-ONS
    #---------------------------------------------------------------------------

    # This following section is to determine compatibility showing for Display
    # Skill Query if you wish for that to be enabled.
    ENABLE_SKILL_QUERY  = true
    SHOW_QUERY_BUTTON   = Input::A
    SHOW_QUERY_HELP_WIN = true
    QUERY_HELP_WIN_TEXT = "Press Shift to view skill info."

  end # SUBCLASS
end # YE

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

module YE
  module REGEXP
    module BASEITEM

      # These are skill related.
      JP_COST       = /<(?:JP_COST|jp cost)[ ]*(\d+)>/i
      JP_BOOST_SET  = /<(?:JP_BOOST_SET|jp boost set)[ ]*(\d+)>/i
      JP_BOOST_RAN  = /<(?:JP_BOOST_RAN|jp boost ran)[ ]*(\d+)>/i
      REQUIRE_SKILL =  /<(?:REQUIRE_SKILL|require skill)[ ]*(\d+)>/i
      REQUIRE_LEVEL =  /<(?:REQUIRE_LEVEL|require level)[ ]*(\d+)>/i

      # These are item related.
      GAIN_JP      = /<(?:GAIN_JP|gain jp)[ ]*(\d+)>/i
      UNLOCK_CLASS = /<(?:UNLOCK_CLASS|unlock class)[ ]*(\d+)>/i
      LOCK_CLASS   = /<(?:LOCK_CLASS|lock class)[ ]*(\d+)>/i
      SET_PRIMARY  = /<(?:SET_PRIMARY|set primary)[ ]*(\d+)>/i
      SET_SUBCLASS = /<(?:SET_SUBCLASS|set subclass)[ ]*(\d+)>/i

    end # BASEITEM
    module ENEMY

      # These are enemy related
      ENEMY_JP     = /<(?:ENEMY_JP|enemy jp)[ ]*(\d+)>/i

    end # ENEMY
    module STATE

      # This affects states.
      BONUS_JP_PER = /<(?:BONUS_JP_PER|bonus jp per)[ ]*(\d+)>/i
      BONUS_JP_SET = /<(?:BONUS_JP_SET|bonus jp set)[ ]*(\d+)>/i

    end # STATE
  end # REGEXP
end # YE

#===============================================================================
# RPG::State
#===============================================================================

class RPG::State

  #--------------------------------------------------------------------------
  # Yanfly_Cache_SSS
  #--------------------------------------------------------------------------
  def yanfly_cache_state_sss
    @bonus_jp_per = 100; @bonus_jp_set = 0

    self.note.split(/[\r\n]+/).each { |line|
      case line
      when YE::REGEXP::STATE::BONUS_JP_PER
        @bonus_jp_per = $1.to_i
      when YE::REGEXP::STATE::BONUS_JP_SET
        @bonus_jp_set = $1.to_i
      end
    }
  end # cache

  #--------------------------------------------------------------------------
  # definitions
  #--------------------------------------------------------------------------
  def bonus_jp_per
    yanfly_cache_state_sss if @bonus_jp_per == nil
    return @bonus_jp_per
  end
  def bonus_jp_set
    yanfly_cache_state_sss if @bonus_jp_set == nil
    return @bonus_jp_set
  end

end

#===============================================================================
# RPG::Enemy
#===============================================================================

class RPG::Enemy

  #--------------------------------------------------------------------------
  # Yanfly_Cache_SSS
  #--------------------------------------------------------------------------
  def yanfly_cache_enemy_sss
    @enemy_jp = YE::SUBCLASS::ENEMIES_DEFAULT

    self.note.split(/[\r\n]+/).each { |line|
      case line
      when YE::REGEXP::ENEMY::ENEMY_JP
        @enemy_jp = $1.to_i
      end
    }
  end # cache

  #--------------------------------------------------------------------------
  # definitions
  #--------------------------------------------------------------------------
  def enemy_jp
    yanfly_cache_enemy_sss if @enemy_jp == nil
    return @enemy_jp
  end

end

#===============================================================================
# RPG::BaseItem
#===============================================================================

class RPG::BaseItem

  #--------------------------------------------------------------------------
  # Yanfly_Cache_SSS
  #--------------------------------------------------------------------------
  def yanfly_cache_baseitem_sss
    @jp_cost = 0; @jp_learn = false; @jp_boost_set = 0; @jp_boost_ran = 0
    @gain_jp = 0; @unlock_class = []; @lock_class = []
    @set_primary = 0; @set_subclass = -1
    @require_skill = []; @require_level = 0

    self.note.split(/[\r\n]+/).each { |line|
      case line
      when YE::REGEXP::BASEITEM::JP_COST
        @jp_cost = $1.to_i
        @jp_learn = true
      when YE::REGEXP::BASEITEM::JP_BOOST_SET
        @jp_boost_set = $1.to_i
      when YE::REGEXP::BASEITEM::JP_BOOST_RAN
        @jp_boost_ran = $1.to_i
      when YE::REGEXP::BASEITEM::GAIN_JP
        @gain_jp = $1.to_i
      when YE::REGEXP::BASEITEM::REQUIRE_SKILL
        @require_skill.push($1.to_i)
      when YE::REGEXP::BASEITEM::REQUIRE_LEVEL
        @require_level = $1.to_i

      when YE::REGEXP::BASEITEM::UNLOCK_CLASS
        @unlock_class.push($1.to_i)
      when YE::REGEXP::BASEITEM::LOCK_CLASS
        @lock_class.push($1.to_i)
      when YE::REGEXP::BASEITEM::SET_PRIMARY
        @set_primary = $1.to_i
      when YE::REGEXP::BASEITEM::SET_SUBCLASS
        @set_subclass = $1.to_i
      end
    }
  end # cache

  #--------------------------------------------------------------------------
  # JP definitions
  #--------------------------------------------------------------------------
  def jp_cost
    yanfly_cache_baseitem_sss if @jp_cost == nil
    return @jp_cost
  end

  def jp_learn?
    yanfly_cache_baseitem_sss if @jp_learn == nil
    return @jp_learn
  end

  def jp_boost_set
    yanfly_cache_baseitem_sss if @jp_boost_set == nil
    return @jp_boost_set
  end

  def jp_boost_ran
    yanfly_cache_baseitem_sss if @jp_boost_ran == nil
    return @jp_boost_ran
  end

  def gain_jp
    yanfly_cache_baseitem_sss if @gain_jp == nil
    return @gain_jp
  end

  def require_skill
    yanfly_cache_baseitem_sss if @require_skill == nil
    return @require_skill
  end

  def require_level
    yanfly_cache_baseitem_sss if @require_level == nil
    return @require_level
  end

  #--------------------------------------------------------------------------
  # class definitions
  #--------------------------------------------------------------------------
  def unlock_class
    yanfly_cache_baseitem_sss if @unlock_class == nil
    return @unlock_class
  end

  def lock_class
    yanfly_cache_baseitem_sss if @lock_class == nil
    return @lock_class
  end

  def set_primary
    yanfly_cache_baseitem_sss if @set_primary == nil
    return @set_primary
  end

  def set_subclass
    yanfly_cache_baseitem_sss if @set_subclass == nil
    return @set_subclass
  end

end

#==============================================================================
# Game_Battler
#==============================================================================

class Game_Battler

  #--------------------------------------------------------------------------
  # perform gain_jp
  #--------------------------------------------------------------------------
  def gain_jp(amount)
    return unless self.actor?
    class1 = self.class_id
    class2 = self.subclass_id unless self.subclass == nil
    for state in states
      amount *= state.bonus_jp_per
      amount /= 100
    end
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      if pri_hash.include?("double jp") or pri_hash.include?("double jp gain")
        amount *= 2
      end
    end
    if YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.class.id) and
    self.subclass != nil
      sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH[self.class.id]
      if sub_hash.include?("double jp") or sub_hash.include?("double jp gain")
        amount *= 2
      end
    end
    for state in states
      amount += state.bonus_jp_set
    end
    jp1  = amount * YE::SUBCLASS::EARN_JP_MULTIPLIER_PRIMARY
    jp1 /= 100
    jp2  = amount * YE::SUBCLASS::EARN_JP_MULTIPLIER_SUBCLASS
    jp2 /= 100
    self.jp_counter += [jp1, jp2].max if $scene.is_a?(Scene_Battle)
    change_jp(class1, jp1)
    change_jp(class2, jp2) unless self.subclass == nil
  end

  #--------------------------------------------------------------------------
  # jp counter
  #--------------------------------------------------------------------------
  def jp_counter
    @jp_counter = 0 if @jp_counter == nil
    return @jp_counter
  end

  def jp_counter=(newvalue)
    @jp_counter = 0 if @jp_counter == nil
    @jp_counter = newvalue
  end

  #--------------------------------------------------------------------------
  # alias attack effect
  #--------------------------------------------------------------------------
  alias attack_effect_sss attack_effect unless $@
  def attack_effect(attacker)
    attack_effect_sss(attacker)
    return unless attacker.actor?
    return unless YE::SUBCLASS::EARN_JP_VIA_ATTACK_ENABLE
    amount  = YE::SUBCLASS::EARN_JP_VIA_ATTACK_AMOUNT
    unless YE::SUBCLASS::EARN_JP_VIA_ATTACK_RANDOM == 0
      amount += rand(YE::SUBCLASS::EARN_JP_VIA_ATTACK_RANDOM)
    end
    attacker.gain_jp(amount)
  end

  #--------------------------------------------------------------------------
  # alias skill effect
  #--------------------------------------------------------------------------
  alias skill_effect_sss skill_effect unless $@
  def skill_effect(user, skill)
    skill_effect_sss(user, skill)
    return unless user.actor?
    return unless YE::SUBCLASS::EARN_JP_VIA_SKILL_ENABLE
    return unless $scene.is_a?(Scene_Battle)
    amount  = YE::SUBCLASS::EARN_JP_VIA_SKILL_AMOUNT
    unless YE::SUBCLASS::EARN_JP_VIA_SKILL_RANDOM == 0
      amount += rand(YE::SUBCLASS::EARN_JP_VIA_SKILL_RANDOM)
    end
    amount += skill.jp_boost_set unless skill.jp_boost_set <= 0
    amount += rand(skill.jp_boost_ran) unless skill.jp_boost_ran <= 0
    user.gain_jp(amount)
  end

  #--------------------------------------------------------------------------
  # alias item effect
  #--------------------------------------------------------------------------
  alias item_effect_sss item_effect unless $@
  def item_effect(user, item)
    item_effect_sss(user, item)
    return unless user.actor?
    user.gain_jp(item.gain_jp)
    #----------------------------------
    if item.unlock_class != []
      for class_id in item.unlock_class
        user.unlock_class(class_id)
      end
    end
    if item.lock_class != []
      for class_id in item.lock_class
        user.lock_class(class_id)
      end
    end
    if item.set_primary > 0
      user.class_id = item.set_primary
    end
    if item.set_subclass > -1
      user.subclass_id = item.set_subclass
    end
    #----------------------------------
    return unless YE::SUBCLASS::EARN_JP_VIA_ITEMS_ENABLE
    return unless $scene.is_a?(Scene_Battle)
    amount  = YE::SUBCLASS::EARN_JP_VIA_ITEMS_AMOUNT
    unless YE::SUBCLASS::EARN_JP_VIA_ITEMS_RANDOM == 0
      amount += rand(YE::SUBCLASS::EARN_JP_VIA_ITEMS_RANDOM)
    end
    user.gain_jp(amount)
  end

  #--------------------------------------------------------------------------
  # alias item test
  #--------------------------------------------------------------------------
  alias item_test_sss item_test unless $@
  def item_test(user, item)
    if self.actor?
      return true if item.unlock_class != []
      return true if item.lock_class != []
      return true if item.gain_jp > 0
      return true if item.set_primary > 0
      return true if item.set_subclass > -1
    end
    return item_test_sss(user, item)
  end

end

#===============================================================================
# Game_Actor
#===============================================================================

class Game_Actor < Game_Battler

  #--------------------------------------------------------------------------
  # Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :subclass_id

  #--------------------------------------------------------------------------
  # alias setup
  #--------------------------------------------------------------------------
  alias setup_sss setup unless $@
  def setup(actor_id)
    setup_sss(actor_id)
    @subclass_id = 0         # This determines the subclass ID.
    @unlocked_classes = [self.class.id]   # What classes are unlocked.
    @class_jp = {}
  end

  #--------------------------------------------------------------------------
  # alias learn skill
  #--------------------------------------------------------------------------
  alias learn_skill_sss learn_skill unless $@
  def learn_skill(skill_id)
    learn_skill_sss(skill_id)
    skill = $data_skills[skill_id]
    if skill.unlock_class != []
      for class_id in skill.unlock_class
        self.unlock_class(class_id)
      end
    end
  end

  #--------------------------------------------------------------------------
  # class actor graphic
  #--------------------------------------------------------------------------
  def class_actor_graphic
    return unless YE::SUBCLASS::CHANGE_ACTOR_GRAPHICS.include?(self.id)
    if YE::SUBCLASS::GRAPHIC_HASH.include?(self.id)
      narray = YE::SUBCLASS::GRAPHIC_HASH[self.id]
    else
      narray = YE::SUBCLASS::GRAPHIC_HASH[0]
    end
    parray = [0, self.character_name, self.character_index,
    self.face_name, self.face_index]
    for tarray in narray
      if @class_id == tarray[0]
        parray = tarray
        break
      end
    end
    val1 = parray[1]; val2 = parray[2]; val3 = parray[3]; val4 = parray[4]
    self.set_graphic(val1, val2, val3, val4)
    return unless $game_party.members[0].id == self.id
    $game_player.set_graphic(val1, val2)
  end

  #--------------------------------------------------------------------------
  # alias class_id=
  #--------------------------------------------------------------------------
  alias class_id_equal_sss class_id=  unless $@
  def class_id=(class_id)
    return if YE::SUBCLASS::SUBCLASS_ONLY_CLASSES.include?(class_id)
    if YE::SUBCLASS::ACTOR_RESTRICTED_CLASSES.include?(self.id)
      unless YE::SUBCLASS::ACTOR_RESTRICTED_CLASSES[self.id].include?(class_id)
        return
      end
    end
    return if class_id == self.class.id
    hp_per = (self.maxhp == 0) ? 0 : self.hp * 100 / self.maxhp
    mp_per = (self.maxmp == 0) ? 0 : self.mp * 100 / self.maxmp
    class_id_equal_sss(class_id)
    class_actor_graphic
    if self.subclass_id == self.class_id
      self.subclass_id = 0
    end
    self.hp = Integer(hp_per * self.maxhp / 100)
    self.mp = Integer(mp_per * self.maxmp / 100)
    if YE::SUBCLASS::ALLOW_RETRO_LEARN
      for i in self.class.learnings
        learn_skill(i.skill_id) if i.level <= @level
      end
    end
    unless @unlocked_classes.include?(@class_id)
      @unlocked_classes.push(@class_id)
    end
    #---
    for i in 0..4
      change_equip(i, nil) unless equippable?(equips[i])
    end
    if $imported["EquipExtension"]
      return if extra_armor_number == 0
      for i in 5..armor_number
        change_equip(i, nil) unless equippable?(equips[i])
      end
    end
    purge_unequippable_skills if $imported["EquipSkillSlots"]
    @unlocked_classes.sort!
  end

  #--------------------------------------------------------------------------
  # return Subclass
  #--------------------------------------------------------------------------
  def subclass
    @subclass_id = 0 if @subclass_id == nil
    return $data_classes[@subclass_id]
  end

  #--------------------------------------------------------------------------
  # change Subclass ID
  #--------------------------------------------------------------------------
  def subclass_id=(newvalue)
    return if YE::SUBCLASS::PRIMARY_ONLY_CLASSES.include?(newvalue)
    if YE::SUBCLASS::ACTOR_RESTRICTED_CLASSES.include?(self.id)
      unless YE::SUBCLASS::ACTOR_RESTRICTED_CLASSES[self.id].include?(newvalue)
        return
      end
    end
    hp_per = (self.maxhp == 0) ? 0 : self.hp * 100 / self.maxhp
    mp_per = (self.maxmp == 0) ? 0 : self.mp * 100 / self.maxmp
    @subclass_id = newvalue
    @subclass_id = 0 if @subclass_id == @class_id
    self.hp = Integer(hp_per * self.maxhp / 100)
    self.mp = Integer(mp_per * self.maxmp / 100)
    return if @subclass_id == 0
    if YE::SUBCLASS::ALLOW_RETRO_LEARN and self.subclass != nil
      for i in self.subclass.learnings
        learn_skill(i.skill_id) if i.level <= @level
      end
    end
    unless @unlocked_classes.include?(@subclass_id)
      @unlocked_classes.push(@subclass_id)
    end
    #---
    for i in 0..4
      change_equip(i, nil) unless equippable?(equips[i])
    end
    if $imported["EquipExtension"]
      return if extra_armor_number == 0
      for i in 5..armor_number
        change_equip(i, nil) unless equippable?(equips[i])
      end
    end
    purge_unequippable_skills if $imported["EquipSkillSlots"]
    @unlocked_classes.sort!
  end

  #--------------------------------------------------------------------------
  # clone class/subclass change
  #--------------------------------------------------------------------------
  def class_clone=(newvalue)
    return if YE::SUBCLASS::SUBCLASS_ONLY_CLASSES.include?(newvalue)
    @class_id = newvalue
    for i in 0..4
      change_equip(i, nil, true) unless equippable?(equips[i])
    end
    if $imported["EquipExtension"]
      return if extra_armor_number == 0
      for i in 5..armor_number
        change_equip(i, nil, true) unless equippable?(equips[i])
      end
    end
  end

  def subclass_clone=(newvalue)
    return if YE::SUBCLASS::PRIMARY_ONLY_CLASSES.include?(newvalue)
    return if newvalue == @class_id
    @subclass_id = newvalue
    @subclass_id = 0 if @subclass_id == @class_id
    for i in 0..4
      change_equip(i, nil, true) unless equippable?(equips[i])
    end
    if $imported["EquipExtension"]
      return if extra_armor_number == 0
      for i in 5..armor_number
        change_equip(i, nil, true) unless equippable?(equips[i])
      end
    end
  end

  #--------------------------------------------------------------------------
  # return unlocked classes
  #--------------------------------------------------------------------------
  def unlocked_classes
    results = []
    @unlocked_classes = [self.class.id] if @unlocked_classes == nil
    @unlocked_classes.sort!
    if YE::SUBCLASS::ACTOR_RESTRICTED_CLASSES.include?(self.id)
      for class_id in @unlocked_classes
        if YE::SUBCLASS::ACTOR_RESTRICTED_CLASSES[self.id].include?(class_id)
          results.push(class_id)
        end
      end
    else
      results = @unlocked_classes
    end
    results.push(self.class.id) unless results.include?(self.class.id)
    return results
  end

  #--------------------------------------------------------------------------
  # perform unlock class
  #--------------------------------------------------------------------------
  def unlock_class(newclass_id)
    @unlocked_classes = [self.class.id] if @unlocked_classes == nil
    unless @unlocked_classes.include?(newclass_id)
      @unlocked_classes.push(newclass_id)
    end
    @unlocked_classes.sort!
    if YE::SUBCLASS::ALLOW_RETRO_LEARN
      newsubclass = $data_classes[newclass_id]
      for i in newsubclass.learnings
        learn_skill(i.skill_id) if i.level <= @level
      end
    end
  end

  #--------------------------------------------------------------------------
  # perform lock class
  #--------------------------------------------------------------------------
  def lock_class(newclass_id)
    return if newclass_id == self.class.id
    @unlocked_classes = [self.class.id] if @unlocked_classes == nil
    @unlocked_classes.delete(newclass_id)
    @unlocked_classes.sort!
  end

  #--------------------------------------------------------------------------
  # perform unlock all classes
  #--------------------------------------------------------------------------
  def unlock_all_classes
    for i in 0..$data_classes.size
      unlock = $data_classes[i + 1]
      self.unlock_class(unlock.id)
    end
    @unlocked_classes.sort!
  end

  #--------------------------------------------------------------------------
  # perform lock all classes
  #--------------------------------------------------------------------------
  def lock_all_classes
    for i in 0..$data_classes.size
      unlock = $data_classes[i + 1]
      self.lock_class(unlock.id)
    end
    @unlocked_classes.sort!
  end

  #--------------------------------------------------------------------------
  # alias equippable?
  #--------------------------------------------------------------------------
  alias equippable_sss equippable? unless $@
  def equippable?(item)
    result = false
    result = equippable_sss(item)
    #---
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      return false unless no_equip_hash(check_hash, item)
      return true if all_equip_hash(check_hash, item)
    end
    #---
    if YE::SUBCLASS::ALLOW_EQUIP and !result and self.subclass != nil
      result = subclass_equippable?(item)
    end
    if YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.class.id) and
    self.subclass != nil
      check_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH[self.class.id]
      return false unless no_equip_hash(check_hash, item)
      return true if all_equip_hash(check_hash, item)
    end
    return result
  end

  #--------------------------------------------------------------------------
  # no equip hash
  #--------------------------------------------------------------------------
  def no_equip_hash(check_hash, item)
    if item.is_a?(RPG::Weapon)
      return false if check_hash.include?("no equip")
      return false if check_hash.include?("no equips")
      return false if check_hash.include?("no equipment")
      return false if check_hash.include?("no weapon")
      return false if check_hash.include?("no weapons")
    elsif item.is_a?(RPG::Armor)
      case item.kind
      when 0
        return false if check_hash.include?("no shield")
        return false if check_hash.include?("no shields")
      when 1
        return false if check_hash.include?("no helmet")
        return false if check_hash.include?("no helmets")
      when 2
        return false if check_hash.include?("no armour")
        return false if check_hash.include?("no armours")
        return false if check_hash.include?("no armor")
        return false if check_hash.include?("no armors")
      when 3
        return false if check_hash.include?("no accessory")
        return false if check_hash.include?("no accessories")
      end
    end
    return true
  end

  #--------------------------------------------------------------------------
  # all equip hash
  #--------------------------------------------------------------------------
  def all_equip_hash(check_hash, item)
    return true if check_hash.include?("all equip")
    return true if check_hash.include?("all equips")
    return true if check_hash.include?("all equipment")
    if item.is_a?(RPG::Weapon)
      return true if check_hash.include?("all weapon")
      return true if check_hash.include?("all weapons")
    elsif item.is_a?(RPG::Armor)
      case item.kind
      when 0
        return true if check_hash.include?("all shield")
        return true if check_hash.include?("all shields")
      when 1
        return true if check_hash.include?("all helmet")
        return true if check_hash.include?("all helmets")
      when 2
        return true if check_hash.include?("all armour")
        return true if check_hash.include?("all armours")
        return true if check_hash.include?("all armor")
        return true if check_hash.include?("all armors")
      when 3
        return true if check_hash.include?("all accessory")
        return true if check_hash.include?("all accessories")
      end
    end
    return false
  end

  #--------------------------------------------------------------------------
  # subclass equippable?
  #--------------------------------------------------------------------------
  def subclass_equippable?(item)
    return false if item == nil
    if item.is_a?(RPG::Weapon) and YE::SUBCLASS::ALLOW_WEAPON
      return self.subclass.weapon_set.include?(item.id)
    elsif item.is_a?(RPG::Armor) and YE::SUBCLASS::ALLOW_ARMOUR
      return false if two_swords_style and item.kind == 0
      return self.subclass.armor_set.include?(item.id)
    end
    return false
  end

  #--------------------------------------------------------------------------
  # alias level_up
  #--------------------------------------------------------------------------
  alias level_up_sss level_up unless $@
  def level_up
    #-----
    prm_rate = YE::SUBCLASS::PRIMARY_GROWTH_RATE
    sub_rate = YE::SUBCLASS::SUBCLASS_GROWTH_RATE
    if YE::SUBCLASS::LEVEL_UP_BONUS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_BONUS_SET.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_BONUS_SET[self.class.id]
        self.maxhp += (narray[0] * prm_rate) / 100
        self.maxmp += (narray[1] * prm_rate) / 100
        self.atk += (narray[2] * prm_rate) / 100
        self.def += (narray[3] * prm_rate) / 100
        self.spi += (narray[4] * prm_rate) / 100
        self.agi += (narray[5] * prm_rate) / 100
      end
    end
    #-----
    if YE::SUBCLASS::BONUS_RANDOM_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_BONUS_RAN.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_BONUS_RAN[self.class.id]
        self.maxhp += (rand(narray[0]) * prm_rate) / 100 unless narray[0] == 0
        self.maxmp += (rand(narray[1]) * prm_rate) / 100 unless narray[1] == 0
        self.atk += (rand(narray[2]) * prm_rate) / 100 unless narray[2] == 0
        self.def += (rand(narray[3]) * prm_rate) / 100 unless narray[3] == 0
        self.spi += (rand(narray[4]) * prm_rate) / 100 unless narray[4] == 0
        self.agi += (rand(narray[5]) * prm_rate) / 100 unless narray[5] == 0
      end
    end
    #-----
    if YE::SUBCLASS::LEVEL_UP_BONUS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_BONUS_SET.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_BONUS_SET[self.class.id]
        self.maxhp += (narray[0] * sub_rate) / 100
        self.maxmp += (narray[1] * sub_rate) / 100
        self.atk += (narray[2] * sub_rate) / 100
        self.def += (narray[3] * sub_rate) / 100
        self.spi += (narray[4] * sub_rate) / 100
        self.agi += (narray[5] * sub_rate) / 100
      end
    end
    #-----
    if YE::SUBCLASS::BONUS_RANDOM_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_BONUS_RAN.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_BONUS_RAN[self.class.id]
        self.maxhp += (rand(narray[0]) * sub_rate) / 100 unless narray[0] == 0
        self.maxmp += (rand(narray[1]) * sub_rate) / 100 unless narray[1] == 0
        self.atk += (rand(narray[2]) * sub_rate) / 100 unless narray[2] == 0
        self.def += (rand(narray[3]) * sub_rate) / 100 unless narray[3] == 0
        self.spi += (rand(narray[4]) * sub_rate) / 100 unless narray[4] == 0
        self.agi += (rand(narray[5]) * sub_rate) / 100 unless narray[5] == 0
      end
    end
    #-----
    if YE::SUBCLASS::ALLOW_RETRO_LEARN and self.subclass != nil
      for i in self.subclass.learnings
        learn_skill(i.skill_id) if i.level <= @level
      end
    end
    #-----
    level_up_sss
  end

  #--------------------------------------------------------------------------
  # alias skills
  #--------------------------------------------------------------------------
  alias skills_sss skills unless $@
  def skills
    original_skills = skills_sss
    allowed_skills = YE::SUBCLASS::CLASS_SKILL_ALLOW[0]
    if YE::SUBCLASS::ACTOR_COMMON_SKILLS.include?(self.id)
      allowed_skills += YE::SUBCLASS::ACTOR_COMMON_SKILLS[self.id]
    end
    if YE::SUBCLASS::CLASS_SKILL_ALLOW.include?(self.class.id)
      allowed_skills += YE::SUBCLASS::CLASS_SKILL_ALLOW[self.class.id]
      if YE::SUBCLASS::PRIMARY_ONLY_SKILLS.include?(self.class.id)
        allowed_skills += YE::SUBCLASS::PRIMARY_ONLY_SKILLS[self.class.id]
      end
    end
    unless self.subclass == nil
      allowed_skills += YE::SUBCLASS::CLASS_SKILL_ALLOW[self.subclass.id]
      if YE::SUBCLASS::SUBCLASS_ONLY_SKILLS.include?(self.subclass.id)
        allowed_skills += YE::SUBCLASS::SUBCLASS_ONLY_SKILLS[self.subclass.id]
      end
    end
    result = []
    for skill in original_skills
      skill_id = skill.id
      result.push(skill) if allowed_skills.include?(skill_id)
    end
    return result
  end

  #--------------------------------------------------------------------------
  # skills_learned
  #--------------------------------------------------------------------------
  def skills_learned(class_id)
    result = []
    if YE::SUBCLASS::CLASS_SKILL_ALLOW.include?(class_id)
      class_skills = YE::SUBCLASS::CLASS_SKILL_ALLOW[class_id]
      if YE::SUBCLASS::PRIMARY_ONLY_SKILLS.include?(class_id)
        class_skills += YE::SUBCLASS::PRIMARY_ONLY_SKILLS[class_id]
      end
      if YE::SUBCLASS::SUBCLASS_ONLY_SKILLS.include?(class_id)
        class_skills += YE::SUBCLASS::SUBCLASS_ONLY_SKILLS[class_id]
      end
      for i in class_skills
        result.push($data_skills[i]) if @skills.include?(i)
      end
    end
    return result
  end

  #--------------------------------------------------------------------------
  # alias base stats
  #--------------------------------------------------------------------------
  alias base_maxhp_sss base_maxhp unless $@
  def base_maxhp
    n = base_maxhp_sss
    if YE::SUBCLASS::AFFECT_STATS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.class.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[0]-100) * YE::SUBCLASS::PRIMARY_STAT_RATE/100)
      n /= 100.0
    end
    if YE::SUBCLASS::AFFECT_STATS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.subclass.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.subclass.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[0]-100) * YE::SUBCLASS::SUBCLASS_STAT_RATE/100)
      n /= 100.0
    end
    boost = false
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      boost = true if check_hash.include?("maxhp up")
    end
    if self.subclass != nil and
    YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.subclass.id]
      boost = true if check_hash.include?("maxhp up")
    end
    if boost
      n *= YE::SUBCLASS::MAXHP_MULTIPLIER
      n /= 100
    end
    return Integer(n)
  end

  alias base_maxmp_sss base_maxmp unless $@
  def base_maxmp
    n = base_maxmp_sss
    if YE::SUBCLASS::AFFECT_STATS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.class.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[1]-100) * YE::SUBCLASS::PRIMARY_STAT_RATE/100)
      n /= 100.0
    end
    if YE::SUBCLASS::AFFECT_STATS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.subclass.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.subclass.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[1]-100) * YE::SUBCLASS::SUBCLASS_STAT_RATE/100)
      n /= 100.0
    end
    boost = false
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      boost = true if check_hash.include?("maxmp up")
    end
    if self.subclass != nil and
    YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.subclass.id]
      boost = true if check_hash.include?("maxmp up")
    end
    if boost
      n *= YE::SUBCLASS::MAXHP_MULTIPLIER
      n /= 100
    end
    return Integer(n)
  end

  alias base_atk_sss base_atk unless $@
  def base_atk
    n = base_atk_sss
    if YE::SUBCLASS::AFFECT_STATS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.class.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[2]-100) * YE::SUBCLASS::PRIMARY_STAT_RATE/100)
      n /= 100.0
    end
    if YE::SUBCLASS::AFFECT_STATS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.subclass.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.subclass.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[2]-100) * YE::SUBCLASS::SUBCLASS_STAT_RATE/100)
      n /= 100.0
    end
    boost = false
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      boost = true if check_hash.include?("atk up")
    end
    if self.subclass != nil and
    YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.subclass.id]
      boost = true if check_hash.include?("atk up")
    end
    if boost
      n *= YE::SUBCLASS::MAXHP_MULTIPLIER
      n /= 100
    end
    unless $imported["BattlerStatBarehand"]
      barehand_trait = false
      if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id) and
      self.weapons[0] == nil and self.weapons[1] == nil
        check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
        barehand_trait = true if check_hash.include?("barehanded")
        barehand_trait = true if check_hash.include?("barehands")
      end
      if self.subclass != nil and !barehand_trait
        if YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id) and
        self.weapons[0] == nil and self.weapons[1] == nil
        check_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH[self.subclass.id]
          barehand_trait = true if check_hash.include?("barehanded")
          barehand_trait = true if check_hash.include?("barehands")
        end
      end
      n = barehanded_multiplier(n) if barehand_trait
    end
    return Integer(n)
  end

  unless method_defined?(:barehanded_multiplier)
  def barehanded_multiplier(value)
    value *= YE::SUBCLASS::BAREHAND_MULTIPLIER
    value /= 100
    return value
  end
  end

  alias base_def_sss base_def unless $@
  def base_def
    n = base_def_sss
    if YE::SUBCLASS::AFFECT_STATS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.class.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[3]-100) * YE::SUBCLASS::PRIMARY_STAT_RATE/100)
      n /= 100.0
    end
    if YE::SUBCLASS::AFFECT_STATS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.subclass.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.subclass.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[3]-100) * YE::SUBCLASS::SUBCLASS_STAT_RATE/100)
      n /= 100.0
    end
    boost = false
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      boost = true if check_hash.include?("def up")
    end
    if self.subclass != nil and
    YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.subclass.id]
      boost = true if check_hash.include?("def up")
    end
    if boost
      n *= YE::SUBCLASS::MAXHP_MULTIPLIER
      n /= 100
    end
    return Integer(n)
  end

  alias base_spi_sss base_spi unless $@
  def base_spi
    n = base_spi_sss
    if YE::SUBCLASS::AFFECT_STATS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.class.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[4]-100) * YE::SUBCLASS::PRIMARY_STAT_RATE/100)
      n /= 100.0
    end
    if YE::SUBCLASS::AFFECT_STATS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.subclass.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.subclass.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[4]-100) * YE::SUBCLASS::SUBCLASS_STAT_RATE/100)
      n /= 100.0
    end
    boost = false
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      boost = true if check_hash.include?("spi up")
    end
    if self.subclass != nil and
    YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.subclass.id]
      boost = true if check_hash.include?("spi up")
    end
    if boost
      n *= YE::SUBCLASS::MAXHP_MULTIPLIER
      n /= 100
    end
    return Integer(n)
  end

  alias base_agi_sss base_agi unless $@
  def base_agi
    n = base_agi_sss
    if YE::SUBCLASS::AFFECT_STATS_PRIMARY
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.class.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.class.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[5]-100) * YE::SUBCLASS::PRIMARY_STAT_RATE/100)
      n /= 100.0
    end
    if YE::SUBCLASS::AFFECT_STATS_SUBCLASS and self.subclass != nil
      if YE::SUBCLASS::CLASS_STAT_RATE.include?(self.subclass.id)
        narray = YE::SUBCLASS::CLASS_STAT_RATE[self.subclass.id]
      else
        narray = YE::SUBCLASS::CLASS_STAT_RATE[0]
      end
      n *= 100 + ((narray[5]-100) * YE::SUBCLASS::SUBCLASS_STAT_RATE/100)
      n /= 100.0
    end
    boost = false
    if YE::SUBCLASS::PRIMARY_TRAITS_HASH.include?(self.class.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.class.id]
      boost = true if check_hash.include?("agi up")
    end
    if self.subclass != nil and
    YE::SUBCLASS::SUBCLASS_TRAITS_HASH.include?(self.subclass.id)
      check_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH[self.subclass.id]
      boost = true if check_hash.include?("agi up")
    end
    if boost
      n *= YE::SUBCLASS::MAXHP_MULTIPLIER
      n /= 100
    end
    return Integer(n)
  end

  #--------------------------------------------------------------------------
  # return class_jp
  #--------------------------------------------------------------------------
  def class_jp(id_value)
    @class_jp = {} if @class_jp == nil
    @class_jp[id_value] = 0 if @class_jp[id_value] == nil
    limit = YE::SUBCLASS::MAX_JP_EARNED
    @class_jp[id_value] = [@class_jp[id_value], limit].min
    return @class_jp[id_value]
  end

  #--------------------------------------------------------------------------
  # action change jp
  #--------------------------------------------------------------------------
  def change_jp(id_value, jp_earned = 1)
    @class_jp = {} if @class_jp == nil
    @class_jp[id_value] = 0 if @class_jp[id_value] == nil
    @class_jp[id_value] += jp_earned
    limit = YE::SUBCLASS::MAX_JP_EARNED
    @class_jp[id_value] = [[@class_jp[id_value], limit].min, 0].max
  end

  #--------------------------------------------------------------------------
  # forget all skills
  #--------------------------------------------------------------------------
  def forget_all_skills
    @skills = []
  end

  #--------------------------------------------------------------------------
  # alias auto battle
  #--------------------------------------------------------------------------
  alias auto_battle_sss auto_battle unless $@
  def auto_battle
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("auto battle")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("auto battle")
    end
    auto_battle_sss
  end

  #--------------------------------------------------------------------------
  # alias super guard
  #--------------------------------------------------------------------------
  alias super_guard_sss super_guard unless $@
  def super_guard
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("super guard")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("super guard")
    end
    super_guard_sss
  end

  #--------------------------------------------------------------------------
  # alias pharmacology
  #--------------------------------------------------------------------------
  alias pharmacology_sss pharmacology unless $@
  def pharmacology
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("pharmacology")
      return true if pri_hash[self.class.id].include?("item boost")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("pharmacology")
      return true if sub_hash[self.subclass.id].include?("item boost")
    end
    pharmacology_sss
  end

  #--------------------------------------------------------------------------
  # alias fast attack
  #--------------------------------------------------------------------------
  alias fast_attack_sss fast_attack unless $@
  def fast_attack
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("fast attack")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("fast attack")
    end
    fast_attack_sss
  end

  #--------------------------------------------------------------------------
  # alias dual_attack
  #--------------------------------------------------------------------------
  alias dual_attack_sss dual_attack unless $@
  def dual_attack
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("dual attack")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("dual attack")
    end
    dual_attack_sss
  end

  #--------------------------------------------------------------------------
  # alias prevent_critical
  #--------------------------------------------------------------------------
  alias prevent_critical_sss prevent_critical unless $@
  def prevent_critical
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("prevent critical")
      return true if pri_hash[self.class.id].include?("prevent crit")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("prevent critical")
      return true if sub_hash[self.subclass.id].include?("prevent crit")
    end
    prevent_critical_sss
  end

  #--------------------------------------------------------------------------
  # alias half_mp_cost
  #--------------------------------------------------------------------------
  alias half_mp_cost_sss half_mp_cost unless $@
  def half_mp_cost
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("half mp cost")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("half mp cost")
    end
    half_mp_cost_sss
  end

  #--------------------------------------------------------------------------
  # alias double_exp_gain
  #--------------------------------------------------------------------------
  alias double_exp_gain_sss double_exp_gain unless $@
  def double_exp_gain
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("double exp gain")
      return true if pri_hash[self.class.id].include?("double exp")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("double exp gain")
      return true if sub_hash[self.subclass.id].include?("double exp")
    end
    double_exp_gain_sss
  end

  #--------------------------------------------------------------------------
  # alias auto_hp_recover
  #--------------------------------------------------------------------------
  alias auto_hp_recover_sss auto_hp_recover unless $@
  def auto_hp_recover
    pri_hash = YE::SUBCLASS::PRIMARY_TRAITS_HASH
    sub_hash = YE::SUBCLASS::SUBCLASS_TRAITS_HASH
    if pri_hash.include?(self.class.id)
      return true if pri_hash[self.class.id].include?("auto hp recover")
      return true if pri_hash[self.class.id].include?("auto hp regen")
    end
    if self.subclass != nil and sub_hash.include?(self.subclass.id)
      return true if sub_hash[self.subclass.id].include?("auto hp recover")
      return true if sub_hash[self.subclass.id].include?("auto hp regen")
    end
    auto_hp_recover_sss
  end

end # end Game Actor

#==============================================================================
# Game_Troop
#==============================================================================

class Game_Troop < Game_Unit

  #--------------------------------------------------------------------------
  # JP Total
  #--------------------------------------------------------------------------
  def jp_total
    jp = 0
    for enemy in dead_members
      jp += enemy.enemy.enemy_jp unless enemy.hidden
    end
    return jp
  end

end # Game_Troop

#==============================================================================
# Window_Command (imported from KGC)
#==============================================================================

class Window_Command < Window_Selectable
unless method_defined?(:add_command)
  #--------------------------------------------------------------------------
  # add command
  #--------------------------------------------------------------------------
  def add_command(command)
    @commands << command
    @item_max = @commands.size
    item_index = @item_max - 1
    refresh_command
    draw_item(item_index)
    return item_index
  end
  #--------------------------------------------------------------------------
  # refresh command
  #--------------------------------------------------------------------------
  def refresh_command
    buf = self.contents.clone
    self.height = [self.height, row_max * WLH + 32].max
    create_contents
    self.contents.blt(0, 0, buf, buf.rect)
    buf.dispose
  end
  #--------------------------------------------------------------------------
  # insert command
  #--------------------------------------------------------------------------
  def insert_command(index, command)
    @commands.insert(index, command)
    @item_max = @commands.size
    refresh_command
    refresh
  end
  #--------------------------------------------------------------------------
  # remove command
  #--------------------------------------------------------------------------
  def remove_command(command)
    @commands.delete(command)
    @item_max = @commands.size
    refresh
  end
end
end

#==============================================================================
# Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base

  #--------------------------------------------------------------------------
  # alias process_battle_start
  #--------------------------------------------------------------------------
  alias process_battle_start_sss process_battle_start unless $@
  def process_battle_start
    for actor in $game_party.members
      actor.jp_counter = 0
    end
    process_battle_start_sss
  end

  #--------------------------------------------------------------------------
  # alias execute_action_guard
  #--------------------------------------------------------------------------
  alias execute_action_guard_sss execute_action_guard unless $@
  def execute_action_guard
    execute_action_guard_sss
    return unless @active_battler.actor?
    return unless YE::SUBCLASS::EARN_JP_VIA_GUARD_ENABLE
    amount  = YE::SUBCLASS::EARN_JP_VIA_GUARD_AMOUNT
    unless YE::SUBCLASS::EARN_JP_VIA_GUARD_RANDOM == 0
      amount += rand(YE::SUBCLASS::EARN_JP_VIA_GUARD_RANDOM)
    end
    @active_battler.gain_jp(amount)
  end

  #--------------------------------------------------------------------------
  # alias display_exp_and_gold
  #--------------------------------------------------------------------------
  alias display_exp_and_gold_sss display_exp_and_gold unless $@
  def display_exp_and_gold
    display_exp_and_gold_sss
    return unless YE::SUBCLASS::USE_JP_SYSTEM
    return unless YE::SUBCLASS::ENEMIES_GIVE_JP
    jp = $game_troop.jp_total
    if jp > 0
      text = sprintf(YE::SUBCLASS::ENEMIES_MESSAGE, $game_party.name, jp)
      $game_message.texts.push(text) if YE::SUBCLASS::ENEMIES_SHOW_MSG
    end
    if YE::SUBCLASS::DISPLAY_ACTOR_JP
      $game_message.new_page
    end
    for actor in $game_party.members
      actor.gain_jp(jp)
      next unless YE::SUBCLASS::DISPLAY_ACTOR_JP
      text = sprintf(YE::SUBCLASS::DISPLAY_ACTOR_MSG, actor.name, actor.jp_counter)
      $game_message.texts.push('\>' + text)
    end
    wait_for_message if YE::SUBCLASS::DISPLAY_ACTOR_JP
  end

end

#===============================================================================
# Scene Menu
#===============================================================================

class Scene_Menu < Scene_Base

  #--------------------------------------------------------------------------
  # alias create command window
  #--------------------------------------------------------------------------
  alias create_command_window_sss create_command_window unless $@
  def create_command_window
    create_command_window_sss
    return if $imported["CustomMenuCommand"]
    if YE::SUBCLASS::MENU_CLASS_CHANGE_OPTION and
    $game_switches[YE::SUBCLASS::ENABLE_CLASS_CHANGE_SWITCH]
      scc_text = YE::SUBCLASS::MENU_CLASS_CHANGE_TITLE
      @command_class_change = @command_window.add_command(scc_text)
      if @command_window.oy > 0
        @command_window.oy -= Window_Base::WLH
      end
    end
    if YE::SUBCLASS::USE_JP_SYSTEM and YE::SUBCLASS::LEARN_SKILL_OPTION and
    $game_switches[YE::SUBCLASS::ENABLE_LEARN_SKILLS_SWITCH]
      scc_text = YE::SUBCLASS::LEARN_SKILL_TITLE
      @command_learn_skill = @command_window.add_command(scc_text)
      if @command_window.oy > 0
        @command_window.oy -= Window_Base::WLH
      end
    end
    @command_window.index = @menu_index
  end

  #--------------------------------------------------------------------------
  # alias update command selection
  #--------------------------------------------------------------------------
  alias update_command_selection_sss update_command_selection unless $@
  def update_command_selection
    call_yerd_command = 0
    if Input.trigger?(Input::C)
      case @command_window.index
      when @command_class_change
        call_yerd_command = 1
      when @command_learn_skill
        call_yerd_command = 1
      end
    end
    if call_yerd_command == 1
      if $game_party.members.size == 0
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      start_actor_selection
      return
    end
    update_command_selection_sss
  end

  #--------------------------------------------------------------------------
  # alias update actor selection
  #--------------------------------------------------------------------------
  alias update_actor_selection_sss update_actor_selection unless $@
  def update_actor_selection
    if Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      Sound.play_decision
      case @command_window.index
      when @command_class_change
        $scene = Scene_Class_Change.new(@status_window.index,
        @command_class_change)
        return
      when @command_learn_skill
        $scene = Scene_Learn_Skill.new(@status_window.index,
        @command_learn_skill)
        return
      end
    end
    update_actor_selection_sss
  end

end # Scene Menu

#===============================================================================
# Scene Class Change
#===============================================================================

class Scene_Class_Change < Scene_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, menu_index = nil)
    @actor_index = actor_index
    @menu_index = menu_index
  end

  #--------------------------------------------------------------------------
  # start process
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    @actor = $game_party.members[@actor_index]
    @actor_window = Window_Class_Change_Actor.new(@actor)
    @status_window = Window_Class_Change_Status.new(@actor)
    @class_window = Window_Class_Change_Jobs.new(@actor)
    create_command_window
    @class_window.refresh
  end

  #--------------------------------------------------------------------------
  # terminate
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @actor_window.dispose
    @status_window.dispose
    @class_window.dispose
    @command_window.dispose
  end

  #--------------------------------------------------------------------------
  # return scene
  #--------------------------------------------------------------------------
  def return_scene
    if $imported["SceneStatusReDux"] and $game_temp.status_menu_flag
      $scene = Scene_Status.new(@actor_index, $game_temp.status_menu_index)
    elsif @menu_index == nil
      $scene = Scene_Map.new
    else
      $scene = Scene_Menu.new(@menu_index)
    end
  end

  #--------------------------------------------------------------------------
  # * Switch to Next Actor Screen
  #--------------------------------------------------------------------------
  def next_actor
    @actor_index += 1
    @actor_index %= $game_party.members.size
    $scene = Scene_Class_Change.new(@actor_index, @menu_index)
  end
  #--------------------------------------------------------------------------
  # * Switch to Previous Actor Screen
  #--------------------------------------------------------------------------
  def prev_actor
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    $scene = Scene_Class_Change.new(@actor_index, @menu_index)
  end

  #--------------------------------------------------------------------------
  # frame update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    if @command_window.active
      update_command_window
    elsif @class_window.active
      update_class_window
    end
  end

  #--------------------------------------------------------------------------
  # create_command_window
  #--------------------------------------------------------------------------
  def create_command_window
    actions = []
    if $game_switches[YE::SUBCLASS::ALLOW_CHANGE_PRIMARY_SWITCH]
      actions.push(YE::SUBCLASS::MENU_CLASS_CHANGE_PRIM)
      @command_primary = actions.size - 1
    end
    if $game_switches[YE::SUBCLASS::ALLOW_CHANGE_SUBCLASS_SWITCH]
      actions.push(YE::SUBCLASS::MENU_CLASS_CHANGE_SUB)
      @command_sub = actions.size - 1
    end
    if YE::SUBCLASS::USE_JP_SYSTEM and
    $game_switches[YE::SUBCLASS::ENABLE_LEARN_SKILLS_SWITCH]
      actions.push(YE::SUBCLASS::MENU_CLASS_CHANGE_LEARN)
      @command_learn = actions.size - 1
    end
    actions.push(YE::SUBCLASS::MENU_CLASS_CHANGE_DONE)
    @command_done = actions.size - 1
    @command_window = Window_Command.new(160, actions, 1, actions.size)
    @command_window.x = 384
    @command_window.y = 0
    @command_window.height = 128
    @command_window.active = true
    @command_window.refresh
  end

  #--------------------------------------------------------------------------
  # update_command_window
  #--------------------------------------------------------------------------
  def update_command_window
    @command_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::UP)
      @class_window.refresh
    elsif Input.trigger?(Input::DOWN)
      @class_window.refresh
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      case @command_window.index
      when @command_done
        return_scene
      when @command_primary
        @last_index = @class_window.item_max + 1
        @command_window.active = false
        @class_window.active = true
        @class_window.refresh
      when @command_sub
        @last_index = @class_window.item_max + 1
        @command_window.active = false
        @class_window.active = true
        @class_window.refresh
      when @command_learn
        $scene = Scene_Learn_Skill.new(@actor_index, @menu_index)
      end
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      next_actor
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      prev_actor
    end
  end

  #--------------------------------------------------------------------------
  # update_class_window
  #--------------------------------------------------------------------------
  def update_class_window
    @class_window.update
    if @last_index != @class_window.index
      @temp_actor = @actor.clone
      if @command_window.index == @command_primary
        class_to_be = $data_classes[@actor.unlocked_classes[@class_window.index]]
        if @temp_actor.subclass_id == class_to_be.id
          unless YE::SUBCLASS::SUBCLASS_ONLY_CLASSES.include?(class_to_be.id)
            @temp_actor.subclass_clone = 0
          end
        end
        @temp_actor.class_clone = class_to_be.id
      elsif @command_window.index == @command_sub
        class_to_be = $data_classes[@actor.unlocked_classes[@class_window.index]]
        if @temp_actor.subclass_id == class_to_be.id
          @temp_actor.subclass_clone = 0
        else
          @temp_actor.subclass_clone = class_to_be.id
        end
      end
      @last_index = @class_window.index
      @status_window.refresh(@temp_actor)
    end
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @command_window.active = true
      @class_window.active = false
      @status_window.refresh
      @temp_actor = nil
    elsif Input.trigger?(Input::C)
      case @command_window.index
      when @command_primary
        determine_primary
      when @command_sub
        determine_subclass
      end
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      next_actor
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      prev_actor
    end
  end

  #--------------------------------------------------------------------------
  # determine primary
  #--------------------------------------------------------------------------
  def determine_primary
    class_to_be = $data_classes[@actor.unlocked_classes[@class_window.index]]
    if class_to_be == @actor.class
      Sound.play_buzzer
    elsif YE::SUBCLASS::SUBCLASS_ONLY_CLASSES.include?(class_to_be.id)
      Sound.play_buzzer
    elsif class_to_be == @actor.subclass
      Sound.play_equip
      @actor.class_id = class_to_be.id
      @actor.subclass_id = 0
      scene_refresh(@temp_actor)
    else
      Sound.play_equip
      @actor.class_id = class_to_be.id
      scene_refresh(@temp_actor)
    end
  end

  #--------------------------------------------------------------------------
  # determine subclass
  #--------------------------------------------------------------------------
  def determine_subclass
    class_to_be = $data_classes[@actor.unlocked_classes[@class_window.index]]
    if class_to_be == @actor.class
      Sound.play_buzzer
    elsif YE::SUBCLASS::PRIMARY_ONLY_CLASSES.include?(class_to_be.id)
      Sound.play_buzzer
    else
      Sound.play_equip
      if @actor.subclass_id == class_to_be.id
        @actor.subclass_id = 0
      else
        @actor.subclass_id = class_to_be.id
      end
      scene_refresh(@temp_actor)
    end
  end

  #--------------------------------------------------------------------------
  # scene_refresh
  #--------------------------------------------------------------------------
  def scene_refresh(fake = nil)
    @actor_window.refresh
    @class_window.refresh
    @status_window.refresh(fake)
  end

  #--------------------------------------------------------------------------
  # index_primary
  #--------------------------------------------------------------------------
  def index_primary
    if @command_window != nil
      return true if @command_window.index == @command_primary
    end
    return false
  end

  #--------------------------------------------------------------------------
  # index_subclass
  #--------------------------------------------------------------------------
  def index_subclass
    if @command_window != nil
      return true if @command_window.index == @command_sub
    end
    return false
  end

end # Scene Class Change

#===============================================================================
# Scene Learn Skill
#===============================================================================

class Scene_Learn_Skill < Scene_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, menu_index = nil)
    @actor_index = actor_index
    @menu_index = menu_index
    @last_index = -100
  end

  #--------------------------------------------------------------------------
  # start process
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    @actor = $game_party.members[@actor_index]
    @help_window = Window_Help.new
    if $imported["HelpExtension"]
      @help_window.row_max = KGC::HelpExtension::ROW_MAX
    end
    dy = @help_window.height
    @status_window = Window_Learn_Skill_Status.new(384, dy, @actor)
    dy += 56
    dh = 416 - @help_window.height - 56
    @class_window = Window_Learn_Skill_Classes.new(0, dy, 384, dh, @actor)
    create_command_window
    create_skill_query
  end

  #--------------------------------------------------------------------------
  # terminate
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @help_window.dispose
    @status_window.dispose
    @class_window.dispose
    @command_window.dispose
    @skill_data_window.dispose if @skill_data_window != nil
    @help_info_window.dispose if @help_info_window != nil
  end

  #--------------------------------------------------------------------------
  # return scene
  #--------------------------------------------------------------------------
  def return_scene
    if $imported["SceneStatusReDux"] and $game_temp.status_menu_flag
      $scene = Scene_Status.new(@actor_index, $game_temp.status_menu_index)
    elsif @menu_index == nil
      $scene = Scene_Map.new
    else
      $scene = Scene_Menu.new(@menu_index)
    end
  end

  #--------------------------------------------------------------------------
  # create_command_window
  #--------------------------------------------------------------------------
  def create_command_window
    actions = []
    actions.push(YE::SUBCLASS::LEARN_SKILL_SELECT)
    @command_select = actions.size - 1
    if YE::SUBCLASS::MENU_CLASS_CHANGE_OPTION and
    $game_switches[YE::SUBCLASS::ENABLE_CLASS_CHANGE_SWITCH]
      actions.push(YE::SUBCLASS::LEARN_SKILL_CHANGE)
      @command_change = actions.size - 1
    end
    actions.push(YE::SUBCLASS::LEARN_SKILL_DONE)
    @command_done = actions.size - 1
    @command_window = Window_Command.new(384, actions, actions.size)
    @command_window.x = 0
    @command_window.y = @help_window.height
    @command_window.active = true
    @command_window.refresh
  end

  #--------------------------------------------------------------------------
  # create skill query
  #--------------------------------------------------------------------------
  def create_skill_query
    return unless $imported["DisplaySkillQuery"]
    return unless YE::SUBCLASS::ENABLE_SKILL_QUERY
    sdy = @help_window.height
    sdh = 416 - sdy
    @skill_data_window = Window_Skill_Data.new(0, sdy, 272, sdh)
    @skill_data_window.active = false
    @help_info_window = Window_Base.new(0, sdy, 384, 56)
    text = YE::SUBCLASS::QUERY_HELP_WIN_TEXT
    @help_info_window.contents.draw_text(2, 0, 344, 24, text, 1)
    @help_info_window.visible = false
  end

  #--------------------------------------------------------------------------
  # * Switch to Next Actor Screen
  #--------------------------------------------------------------------------
  def next_actor
    @actor_index += 1
    @actor_index %= $game_party.members.size
    $scene = Scene_Learn_Skill.new(@actor_index, @menu_index)
  end
  #--------------------------------------------------------------------------
  # * Switch to Previous Actor Screen
  #--------------------------------------------------------------------------
  def prev_actor
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    $scene = Scene_Learn_Skill.new(@actor_index, @menu_index)
  end

  #--------------------------------------------------------------------------
  # frame update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    if $imported["DisplaySkillQuery"] and @skill_data_window.active
      update_skill_query_window
    elsif @command_window.active
      update_command_window
    elsif @class_window.active
      update_class_window
    elsif @skill_list_window != nil
      update_skill_list_window
    end
  end

  #--------------------------------------------------------------------------
  # update_skill_query_window
  #--------------------------------------------------------------------------
  def update_skill_query_window
    @skill_data_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @skill_data_window.disappear
      @skill_list_window.active = true
    elsif Input.trigger?(Input::LEFT) or Input.trigger?(Input::UP)
      @skill_data_window.previous_page
    elsif Input.trigger?(Input::RIGHT) or Input.trigger?(Input::DOWN)
      @skill_data_window.next_page
    elsif Input.trigger?(Input::L)
      @skill_data_window.top_page
    elsif Input.trigger?(Input::R)
      @skill_data_window.bottom_page
    end
  end

  #--------------------------------------------------------------------------
  # update_command_window
  #--------------------------------------------------------------------------
  def update_command_window
    @command_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      case @command_window.index
      when @command_done
        return_scene
      when @command_select
        Sound.play_decision
        @class_window.active = true
        @command_window.active = false
        class_id = $data_classes[@actor.unlocked_classes[@class_window.index]].id
        @status_window.refresh(class_id)
        text = YE::SUBCLASS::LEARN_SKILL_STATUS_HELP
        @help_window.set_text(text)
      when @command_change
        $scene = Scene_Class_Change.new(@actor_index, @menu_index)
      end
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      next_actor
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      prev_actor
    end
  end

  #--------------------------------------------------------------------------
  # update_class_window
  #--------------------------------------------------------------------------
  def update_class_window
    @class_window.update
    if @last_index != @class_window.index
      class_id = $data_classes[@actor.unlocked_classes[@class_window.index]].id
      @status_window.refresh(class_id)
      @last_index = @class_window.index
    end
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @class_window.active = false
      @command_window.active = true
      @status_window.refresh
      @help_window.set_text("")
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      class_id = $data_classes[@actor.unlocked_classes[@class_window.index]].id
      @skill_list_window = Window_Learn_Skill_List.new(@class_window, @actor, class_id)
      @skill_list_window.help_window = @help_window
      @class_window.active = false
      @class_window.visible = false
      show_query_info
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      next_actor
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      prev_actor
    end
  end

  #--------------------------------------------------------------------------
  # update_skill_list_window
  #--------------------------------------------------------------------------
  def update_skill_list_window
    @skill_list_window.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      @class_window.active = true
      @class_window.visible = true
      @skill_list_window.dispose
      text = YE::SUBCLASS::LEARN_SKILL_STATUS_HELP
      @help_window.set_text(text)
      hide_query_info
    elsif Input.trigger?(Input::C)
      unless @skill_list_window.skill_id == nil
        skill = $data_skills[@skill_list_window.skill_id]
        if @actor.skill_learn?(skill)
          Sound.play_buzzer
        elsif skill.require_level >= @actor.level
          Sound.play_buzzer
        elsif !met_skill_requirements(skill)
          Sound.play_buzzer
        elsif skill.jp_cost > @actor.class_jp(@skill_list_window.class_id)
          Sound.play_buzzer
        else
          YE::SUBCLASS::LEARN_SKILL_SHOP_SOUND.play
          @actor.learn_skill(skill.id)
          @actor.change_jp(@skill_list_window.class_id, -skill.jp_cost)
          @skill_list_window.refresh
          @status_window.refresh(@skill_list_window.class_id)
          @class_window.refresh
        end
      end
    elsif $imported["DisplaySkillQuery"] and
    Input.trigger?(YE::SUBCLASS::SHOW_QUERY_BUTTON)
      if @skill_list_window.skill_id == nil
        skill = nil
      else
        skill = $data_skills[@skill_list_window.skill_id]
      end
      if skill != nil
        Sound.play_decision
        @skill_data_window.appear(skill, @skill_list_window, @actor, 2)
        @skill_list_window.active = false
      else
        Sound.play_buzzer
      end
    end
  end

  #--------------------------------------------------------------------------
  # met skill requirements
  #--------------------------------------------------------------------------
  def met_skill_requirements(skill)
    return true if skill.require_skill == []
    total_met = 0
    for skill_id in skill.require_skill
      if @actor.skill_learn?($data_skills[skill_id])
        total_met += 1
      end
    end
    if total_met == skill.require_skill.size
      return true
    else
      return false
    end
  end

  #--------------------------------------------------------------------------
  # show/hide query info
  #--------------------------------------------------------------------------
  def show_query_info
    return unless $imported["DisplaySkillQuery"]
    return unless YE::SUBCLASS::SHOW_QUERY_HELP_WIN
    @help_info_window.visible = true
    @command_window.visible = false
  end

  def hide_query_info
    return unless $imported["DisplaySkillQuery"]
    return unless YE::SUBCLASS::SHOW_QUERY_HELP_WIN
    @help_info_window.visible = false
    @command_window.visible = true
  end

end # Scene_Learn_Skill

#===============================================================================
# Scene Title
#===============================================================================

class Scene_Title < Scene_Base

  #--------------------------------------------------------------------------
  # alias create game objects
  #--------------------------------------------------------------------------
  alias create_game_objects_sss create_game_objects unless $@
  def create_game_objects
    create_game_objects_sss
    $game_switches[YE::SUBCLASS::ALLOW_CHANGE_PRIMARY_SWITCH] = true
    $game_switches[YE::SUBCLASS::ALLOW_CHANGE_SUBCLASS_SWITCH] = true
    $game_switches[YE::SUBCLASS::ENABLE_CLASS_CHANGE_SWITCH] = true
    $game_switches[YE::SUBCLASS::ENABLE_LEARN_SKILLS_SWITCH] = true
  end

end # Scene_Title

#===============================================================================
# Window_Base
#===============================================================================

class Window_Base < Window

  #--------------------------------------------------------------------------
  # Draw Actor Class
  #--------------------------------------------------------------------------
  def draw_actor_class(actor, x, y, wd = 120, align = 0)
    if actor.subclass == nil
      text = actor.class.name
    else
      text = sprintf(YE::SUBCLASS::DISPLAY_FORMAT, actor.class.name,
      actor.subclass.name)
    end
    if YE::SUBCLASS::USE_COMPLEX_CLASS_NAMES
      if YE::SUBCLASS::COMPLEX_CLASS_NAMES_FULL.include?(text)
        text = YE::SUBCLASS::COMPLEX_CLASS_NAMES_FULL[text]
      end
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, wd, WLH, text, align)
  end

  #--------------------------------------------------------------------------
  # Draw Actor Class Abbreviated
  #--------------------------------------------------------------------------
  def draw_actor_class_abbr(actor, x, y, wd = 120, align = 0)
    if actor.subclass == nil
      text = YE::SUBCLASS::CLASS_ABBREVIATIONS[actor.class.id]
    else
      class1 = YE::SUBCLASS::CLASS_ABBREVIATIONS[actor.class.id]
      class2 = YE::SUBCLASS::CLASS_ABBREVIATIONS[actor.subclass.id]
      text = sprintf(YE::SUBCLASS::DISPLAY_FORMAT, class1, class2)
    end
    if YE::SUBCLASS::USE_COMPLEX_CLASS_NAMES
      if YE::SUBCLASS::COMPLEX_CLASS_NAMES_ABBR.include?(text)
        text = YE::SUBCLASS::COMPLEX_CLASS_NAMES_ABBR[text]
      end
    end
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, wd, WLH, text, align)
  end

end

#===============================================================================
# Window Class Change Actor
#===============================================================================

class Window_Class_Change_Actor < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 0, 384, 128)
    @actor = actor
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_face(@actor, 0, 0)
    y = 0
    draw_actor_name(@actor, 116, y)
    if YE::SUBCLASS::CLASS_ICONS.include?(@actor.class.id)
      icon = YE::SUBCLASS::CLASS_ICONS[@actor.class.id]
    else
      icon = YE::SUBCLASS::CLASS_ICONS[0]
    end
    if @actor.subclass != nil
      y += WLH
      draw_actor_class(@actor, 116, y, 200, 0)
    end
    y += WLH
    sety = y
    draw_icon(icon, 116, y)
    self.contents.draw_text(140, y, 112, WLH, @actor.class.name, 0)
    if @actor.subclass != nil
      if YE::SUBCLASS::CLASS_ICONS.include?(@actor.subclass.id)
        icon = YE::SUBCLASS::CLASS_ICONS[@actor.subclass.id]
      else
        icon = YE::SUBCLASS::CLASS_ICONS[0]
      end
      y += WLH
      draw_icon(icon, 116, y)
      self.contents.draw_text(140, y, 112, WLH, @actor.subclass.name, 0)
    end
    if YE::SUBCLASS::USE_JP_SYSTEM
      y = sety
      icon = YE::SUBCLASS::JP_ICON
      draw_icon(icon, 256, y)
      class_id = @actor.class.id
      text = sprintf(YE::SUBCLASS::JP_DEFINITION, @actor.class_jp(class_id))
      self.contents.draw_text(268, y, 80, WLH, text, 2)
      y += WLH
      if @actor.subclass != nil
        draw_icon(icon, 256, y)
        class_id = @actor.subclass.id
        text = sprintf(YE::SUBCLASS::JP_DEFINITION, @actor.class_jp(class_id))
        self.contents.draw_text(268, y, 80, WLH, text, 2)
      end
    end
  end # end refresh

end # End Window Class Change Actor

#==============================================================================
# Window_Class_Change_Jobs
#==============================================================================

class Window_Class_Change_Jobs < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(272, 128, 272, 288)
    @actor = actor
    @column_max = 1
    self.index = 0
    self.active = false
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for class_id in @actor.unlocked_classes
      @data.push(class_id)
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end

  #--------------------------------------------------------------------------
  # draw item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    iclass = $data_classes[@actor.unlocked_classes[index]]
    if iclass.id != 0
      rect.width -= 4
      enabled = true
      enabled = false if iclass == @actor.class
      enabled = false if iclass == @actor.subclass
      if $scene.index_primary
        if YE::SUBCLASS::SUBCLASS_ONLY_CLASSES.include?(iclass.id)
          enabled = false
        end
      elsif $scene.index_subclass
        if YE::SUBCLASS::PRIMARY_ONLY_CLASSES.include?(iclass.id)
          enabled = false
        end
      end
      if YE::SUBCLASS::CLASS_ICONS.include?(iclass.id)
        icon = YE::SUBCLASS::CLASS_ICONS[iclass.id]
      else
        icon = YE::SUBCLASS::CLASS_ICONS[0]
      end
      draw_icon(icon, rect.x, rect.y, enabled)
      dx = rect.x
      dy = rect.y
      dw = rect.width
      dh = rect.height
      self.contents.font.color.alpha = enabled ? 255 : 128
      self.contents.draw_text(dx+24, dy, dw-48, dh, iclass.name, 0)
      if YE::SUBCLASS::USE_JP_SYSTEM
        icon = YE::SUBCLASS::JP_ICON
        draw_icon(icon, rect.width-24, rect.y, enabled)
        jp = @actor.class_jp(iclass.id)
        self.contents.draw_text(dw-104, dy, 80, dh, jp, 2)
      end
    end
  end

end # Window_Class_Change_Jobs

#===============================================================================
# Window Class Change Status
#===============================================================================

class Window_Class_Change_Status < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(actor)
    super(0, 128, 272, 288)
    @real = actor
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(fake = nil)
    self.contents.clear
    self.contents.font.color = normal_color
    if YE::SUBCLASS::CLASS_ICONS.include?(@real.class.id)
      icon1 = YE::SUBCLASS::CLASS_ICONS[@real.class.id]
    else
      icon1 = YE::SUBCLASS::CLASS_ICONS[0]
    end
    if @real.subclass != nil
      if YE::SUBCLASS::CLASS_ICONS.include?(@real.subclass.id)
        icon2 = YE::SUBCLASS::CLASS_ICONS[@real.subclass.id]
      else
        icon2 = YE::SUBCLASS::CLASS_ICONS[0]
      end
      draw_icon(icon2, 50, 0)
    end
    draw_icon(icon1, 26, 0)
    self.contents.font.color = system_color
    draw_actor_class_abbr(@real, 80, 0, 60, 2)
    dx = 0
    dy = WLH
    self.contents.font.color = system_color
    for i in 0..5
      text = YE::SUBCLASS::MENU_CLASS_CHANGE_PARAM[i]
      icon = YE::SUBCLASS::MENU_CLASS_CHANGE_ICONS[i]
      draw_icon(icon, dx, dy)
      self.contents.draw_text(dx+24, dy, 60, WLH, text, 0)
      dy += WLH
    end
    dx += 80
    dy = WLH
    self.contents.font.color = normal_color
    for i in 0..5
      case i
      when 0
        text = @real.maxhp
      when 1
        text = @real.maxmp
      when 2
        text = @real.atk
      when 3
        text = @real.def
      when 4
        text = @real.spi
      when 5
        text = @real.agi
      end
      self.contents.draw_text(dx, dy, 60, WLH, text, 2)
      dy += WLH
    end
    dx += 60
    dy = 0
    self.contents.font.color = system_color
    if YE::SUBCLASS::MENU_CLASS_CHANGE_USE_ICON
      icon = YE::SUBCLASS::MENU_CLASS_CHANGE_ICON
      for i in 0..6
        draw_icon(icon, dx+3, dy)
        dy += WLH
      end
    else
      text = YE::SUBCLASS::MENU_CLASS_CHANGE_ARROW
      for i in 0..6
        self.contents.draw_text(dx, dy, 30, WLH, text, 1)
        dy += WLH
      end
    end
    return if fake == nil
    dx += 30
    dy = WLH
    draw_actor_class_abbr(fake, dx, 0, 60, 0)
    for i in 0..5
      case i
      when 0
        old = @real.maxhp
        new = fake.maxhp
      when 1
        old = @real.maxmp
        new = fake.maxmp
      when 2
        old = @real.atk
        new = fake.atk
      when 3
        old = @real.def
        new = fake.def
      when 4
        old = @real.spi
        new = fake.spi
      when 5
        old = @real.agi
        new = fake.agi
      end
      self.contents.font.color = new_parameter_color(old, new)
      if YE::SUBCLASS::MENU_CLASS_CHANGE_SDISPLAY == 1
        text = new
      else
        text = sprintf("%+d", new - old)
      end
      self.contents.draw_text(dx, dy, 60, WLH, text, 0)
      dy += WLH
    end
  end

  #--------------------------------------------------------------------------
  # New Parameter Colour
  #--------------------------------------------------------------------------
  def new_parameter_color(old_value, new_value)
    if new_value > old_value
      return power_up_color
    elsif new_value == old_value
      return normal_color
    else
      return power_down_color
    end
  end

end # End Window Class Change Status

#===============================================================================
# Window Learn Skill Status
#===============================================================================

class Window_Learn_Skill_Status < Window_Base

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    dh = 416 - y
    super(x, y, 160, dh)
    @actor = actor
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh(class_id = nil)
    self.contents.clear
    sw = self.width - 32
    dx = (sw / 2) - 48
    dy = 0
    self.contents.draw_text(0, dy, sw, WLH, @actor.name, 1)
    dy += WLH
    draw_actor_face(@actor, dx, dy)
    return if class_id == nil

    dy += WLH * 4
    if YE::SUBCLASS::CLASS_ICONS.include?(class_id) and class_id != nil
      icon = YE::SUBCLASS::CLASS_ICONS[class_id]
    else
      icon = YE::SUBCLASS::CLASS_ICONS[0]
    end
    draw_icon(icon, 0, dy)
    text = $data_classes[class_id].name
    self.contents.draw_text(24, dy, sw-24, WLH, text, 0)

    dy += WLH
    skills_learned = @actor.skills_learned(class_id).size
    if YE::SUBCLASS::CLASS_SKILL_ALLOW.include?(class_id)
      skill_size = YE::SUBCLASS::CLASS_SKILL_ALLOW[class_id].size
      if YE::SUBCLASS::PRIMARY_ONLY_SKILLS.include?(class_id)
        skill_size += YE::SUBCLASS::PRIMARY_ONLY_SKILLS[class_id].size
      end
      if YE::SUBCLASS::SUBCLASS_ONLY_SKILLS.include?(class_id)
        skill_size += YE::SUBCLASS::SUBCLASS_ONLY_SKILLS[class_id].size
      end
      if skills_learned == skill_size
        text = YE::SUBCLASS::LEARN_SKILL_STATUS_ALL
      else
        mastery = skills_learned * 100
        mastery /= skill_size
        text = sprintf(YE::SUBCLASS::LEARN_SKILL_STATUS_LEARNED, mastery)
      end
      self.contents.draw_text(0, dy, sw, WLH, text, 1)
    end
    dy += WLH
    icon = YE::SUBCLASS::JP_ICON
    draw_icon(icon, 0, dy)
    text = sprintf(YE::SUBCLASS::JP_DEFINITION, @actor.class_jp(class_id))
    self.contents.draw_text(24, dy, sw-24, WLH, text, 2)
  end

end # end class Window_Learn_Skill_Status

#==============================================================================
# Window_Learn_Skill_Classes
#==============================================================================

class Window_Learn_Skill_Classes < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(wx, wy, ww, wh, actor)
    super(wx, wy, ww, wh)
    @actor = actor
    @column_max = 1
    self.index = 0
    self.active = false
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    for class_id in @actor.unlocked_classes
      @data.push(class_id)
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end

  #--------------------------------------------------------------------------
  # draw item
  #--------------------------------------------------------------------------
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    iclass = $data_classes[@actor.unlocked_classes[index]]
    if iclass.id != 0
      rect.width -= 4
      if YE::SUBCLASS::CLASS_ICONS.include?(iclass.id)
        icon = YE::SUBCLASS::CLASS_ICONS[iclass.id]
      else
        icon = YE::SUBCLASS::CLASS_ICONS[0]
      end
      draw_icon(icon, rect.x, rect.y)
      dx = rect.x
      dy = rect.y
      dw = rect.width
      dh = rect.height
      self.contents.draw_text(dx+24, dy, 172, dh, iclass.name, 0)
      icon = YE::SUBCLASS::JP_ICON
      draw_icon(icon, rect.width-24, rect.y)
      text = sprintf(YE::SUBCLASS::JP_DEFINITION, @actor.class_jp(iclass.id))
      self.contents.draw_text(dw-104, dy, 80, dh, text, 2)
    end
  end

end # Window_Learn_Skill_Classes

#==============================================================================
# Window_Learn_Skill_List
#==============================================================================

class Window_Learn_Skill_List < Window_Selectable

  #--------------------------------------------------------------------------
  # initialize
  #--------------------------------------------------------------------------
  def initialize(window, actor, class_id)
    wx = window.x
    wy = window.y
    ww = window.width
    wh = window.height
    super(wx, wy, ww, wh)
    @actor = actor
    @class_id = class_id
    @column_max = 1
    self.index = 0
    self.active = true
    refresh
  end

  #--------------------------------------------------------------------------
  # refresh
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    if YE::SUBCLASS::CLASS_SKILL_ALLOW.include?(@class_id)
      class_skills = YE::SUBCLASS::CLASS_SKILL_ALLOW[@class_id]
      if YE::SUBCLASS::PRIMARY_ONLY_SKILLS.include?(@class_id)
        class_skills += YE::SUBCLASS::PRIMARY_ONLY_SKILLS[@class_id]
      end
      if YE::SUBCLASS::SUBCLASS_ONLY_SKILLS.include?(@class_id)
        class_skills += YE::SUBCLASS::SUBCLASS_ONLY_SKILLS[@class_id]
      end
      for skill_id in class_skills
        @data.push(skill_id) if $data_skills[skill_id].jp_learn?
      end
    end
    for skill in @actor.skills_learned(@class_id)
      @data.push(skill.id)# unless @data.include?(skill.id)
    end
    @data = @data.uniq
    @data.sort!
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end

  #--------------------------------------------------------------------------
  # draw item
  #--------------------------------------------------------------------------
  def draw_item(index)
    skill = $data_skills[@data[index]]
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    rect.width -= 4
    enabled = true
    enabled = false if @actor.skill_learn?(skill)
    enabled = false if skill.require_level >= @actor.level
    enabled = false if skill.jp_cost > @actor.class_jp(@class_id)
    if skill.require_skill == []
      met_skill_requirements = true
    else
      met_skill_requirements = false
      total_met = 0
      reqicon = 0
      for skill_id in skill.require_skill
        if @actor.skill_learn?($data_skills[skill_id])
          total_met += 1
        else
          reqicon = $data_skills[skill_id].icon_index if reqicon == 0
        end
      end
      met_skill_requirements = true if total_met == skill.require_skill.size
    end
    enabled = false unless met_skill_requirements
    dx = rect.x
    dy = rect.y
    dw = rect.width
    dh = rect.height
    sw = self.width - 32
    draw_icon(skill.icon_index, dx, dy, enabled)
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(dx+24, dy, 172, dh, skill.name, 0)

    icon = YE::SUBCLASS::JP_ICON
    if YE::SUBCLASS::PRIMARY_ONLY_SKILLS.include?(@class_id) and
    YE::SUBCLASS::PRIMARY_ONLY_SKILLS[@class_id].include?(skill.id)
      icon = YE::SUBCLASS::PRIMARY_ONLY_ICON
    elsif YE::SUBCLASS::SUBCLASS_ONLY_SKILLS.include?(@class_id) and
    YE::SUBCLASS::SUBCLASS_ONLY_SKILLS[@class_id].include?(skill.id)
      icon = YE::SUBCLASS::SUBCLASS_ONLY_ICON
    end

    if @actor.skill_learn?(skill)
      text = YE::SUBCLASS::LEARN_SKILL_SHOP_LEARNED
    elsif skill.require_level >= @actor.level
      text = sprintf(YE::SUBCLASS::REQUIRE_LEVEL, skill.require_level)
    elsif !met_skill_requirements
      text = YE::SUBCLASS::REQUIRE_SKILL
      icon = reqicon
    else
      text = sprintf(YE::SUBCLASS::LEARN_SKILL_SHOP_STRING, skill.jp_cost)
    end

    self.contents.draw_text(dw-104, dy, 80, dh, text, 2)
    draw_icon(icon, dw-24, dy, enabled)
  end

  #--------------------------------------------------------------------------
  # Skill
  #--------------------------------------------------------------------------
  def skill_id
    return @data[self.index]
  end

  #--------------------------------------------------------------------------
  # class_id
  #--------------------------------------------------------------------------
  def class_id
    return @class_id
  end

  #--------------------------------------------------------------------------
  # update help
  #--------------------------------------------------------------------------
  def update_help
    if self.skill_id != nil
      skill = $data_skills[self.skill_id]
    else
      skill = nil
    end
    @help_window.set_text(skill==nil ? "" : skill.description)
  end

end # Window_Learn_Skill_List

#===============================================================================
#
# END OF FILE
#
#===============================================================================