스테이터스(상태) 관련한 다양한 세팅이 가능합니다.
자세한 내용은 내부 주석을 참고
#===============================================================================
#
# Yanfly Engine RD - Custom Status Properties
# Last Date Updated: 2009.06.24
# Level: Normal, Hard, Lunatic
#
# Status effects seriously don't get enough love in RPG's, both commercial and
# RPG Maker projects. This script will provide more than your bread and butter
# status effect traits. Here are some things this script can do.
#
# - Status effects can raise MaxHP and MaxMP by percentile and set values. Or
# even lower them if that's what's desired.
# - HP and MP degeneration if the usual slip damage is too heavy or light. You
# can even create HP and MP regeneration.
# - If the attack, defense, spirit, and agility rate limit of 200% is too low
# for you, you can break the limit and go to something absurd like 1,000,000%.
# - A status effect that prevents the battler from dying even if the battler is
# at 0 HP, essentially granting the battler a form of immortality.
# - Status effects that greatly reduce HP and/or MP damage given to battlers.
# They can even completely nullify HP and/or MP damage.
# - Can convert a portion of the received HP damage into MP damage and vice
# versa: MP to HP damage.
# - Make battlers vanish from battle and have them return to battle after the
# status effect wears off.
# - A condition similar to berserk and confused, but makes allows the battler
# to use skills using auto battle AI.
# - Custom status effect properties that trigger during any of these five
# situations: applying, while the status is on, when status leaves naturally,
# upon removal, and reacting to attack and skill damage.
# - State stacking. Some effects will stack. The amount they stack will depend
# on the effect the states will produce. Explained below.
#
# I hope you find different ways to use these status effects to spice up one of
# the most overlooked mechanics in many, many RPG's out there.
#
#===============================================================================
# Updates:
# ----------------------------------------------------------------------------
# o 2009.05.12 - Three more Lunatic effect types:
# Begin Effect: Occurs at the start of a turn.
# Shock Effect: Occurs after taking an attack or turn.
# Close Effect: Occurs at the end of a turn.
# o 2009.05.02 - Aliased regen and degen to slip_damage_effect rather than
# remove states auto since it provides more compatibility.
# o 2009.04.28 - State stacking capabilities added.
# o 2009.04.23 - Improved functionality on HECO stat minimums.
# o 2009.04.19 - Upgrade Pack 1
# Added shorter way to use atk/def/spi/agi_f rates.
# Added a state-type hash for the module. Optional usage.
# Included Add/Sub set values for atk/def/spi/agi.
# Included Per/Add/Sub for Hit/Eva/Cri/Odds.
# Included Undead HP/MP. Added Absorb HP/MP.
# Included Death Upon HP/MP Damage/Healing.
# Included HP/MP Pain/Healing Rates.
# Included Super Guard, Pharmacology, Fast Attack, Anti-State.
# Included Double EXP Gain, Half MP Cost, Prevent Critical.
# o 2009.04.18 - Improved REGEXP cache.
# o 2009.04.15 - Finished script and publicized.
# o 2009.04.13 - Started script.
#===============================================================================
# How to Use: Normal Mode
#===============================================================================
#
# Simply input these into the States Notebox and you'll get the effects you're
# looking for. These directly affect stats and don't do anything else funky that
# you don't have to worry about.
#
# <max stack x>
# By default, everything has a maximum stack of of 1. Stacking a state more than
# once will increase its effect. For states that increase by a percentile, the
# stack effect will increase its effect after a difference with 100. This means
# that if a state with 110% attack rate gets stacked, the 10% gets multipled
# instead of the full 110%. Stacking it twice will get 120%. Thrice nets 130%.
# Set changes will stack completely. +50ATK will stack as +100, then +150, and
# so on. Max stack will set the maximum amount of times the state can stack.
# States that can be stacked will be marked as <<STACKABLE>>.
#
# <maxhp per x>, <maxhp add x>, <maxhp sub x>
# <maxmp per x>, <maxmp add x>, <maxmp sub x>
# Sets rate for MaxHP or MP by x percentage, adds x value, or subtracts x value.
# <<STACKABLE>>
#
# <hp degen per x>, <hp degen set x>, <hp regen per x>, <hp regen set x>
# Causes battler to gain or lose HP by x percentage or x amount each turn.
# <<STACKABLE>>
#
# <mp degen per x>, <mp degen set x>, <mp regen per x>, <mp regen set x>
# Causes battler to gain or lose HP by x percentage or x amount each turn.
# <<STACKABLE>>
#
# <atk per x>, <def per x>, <spi per x>, <agi per x>
# <atk add x>, <def add x>, <spi add x>, <agi add x>
# <atk sub x>, <def sub x>, <spi sub x>, <agi sub x>
# These raise and lower the respective stat by a percentile value if using "per"
# or a static value if using "add" or "sub" tags. Value changed is equal to x.
# <<STACKABLE>>
#
# <hit per x>, <hit add x>, <hit sub x>
# <eva per x>, <eva add x>, <eva sub x>
# <cri per x>, <cri add x>, <cri sub x>
# <odds per x>, <odds add x>, <odds sub x>
# These raise and lower the HECO stats by a percentile value if using "per" or
# a static value if using "add" or "sub" tags. Value changed is equal to x.
# <<STACKABLE>>
#
#===============================================================================
# How to Use: Hard Mode
#===============================================================================
#
# Input these into the state notebox as well. These perform unique traits so
# be alert as to what to expect.
#
# <immortality>
# Causes the character affected to be immortal so long as it's on. Immortal
# characters can go to 0 HP but still be able to act. If a character is at 0 HP,
# and the status effect is removed, then that character will die.
#
# <vanish>
# Vanish will remove a character from battle for a bit (until the status effect
# is removed). Until then, that character cannot be targetted, attacked, or
# anything. Even if you target the vanished character with a skill/item, it will
# pick someone else. If there are no other allies but the character is vanished,
# the battle will end as a game over or victory depending on which side has
# insufficient battlers.
#
# <auto battle>
# Causes the character to act as if auto battle is checked. Auto battle will
# make the character attack on its own, but willing to use skills unlike berserk
# and confuse. If the character becomes berserk or confused while having auto
# battle, it won't do anything other than attack, just like normally berserk or
# confused. Once removed, character becomes controllable again.
#
# <half mp cost>
# This gives the battler a Half MP Cost effect. Pretty much the same effect as
# if the battler was equipping a Half MP Cost piece of equipment.
#
# <super guard>
# If the battler defends, damage received will be taken as one quarter of its
# original damage. This is the same effect as if Super Guard was checked under
# the Actors tab in the database.
#
# <pharmacology>
# This doubles the effectiveness of items. It's essentially the same as having
# Pharamcology checked under the Actors tab in the database.
#
# <double exp gain>
# This allows the actor to get double experience if the state is on. It's
# essentially the same as having Double Exp Gain checked in an equip.
#
# <fast attack>
# This raises the initiative for the battler if it is performing a regular
# attack (unless you customize that). It's essentially the same as having a
# weapon with fast attack checked.
#
# <prevent critical>
# Attacks cannot cause critical hits against the battler. This is the same as
# having armour with Prevent Critical checked.
#
# <anti state>
# This prevents the battler from gaining any more states until the anti-state
# is off. States can still be removed but cannot be added onto the battler.
#
# <absorb hp>, <absorb mp>
# If the battler deals HP damage or MP damage (for the respective states),
# all damage is converted to absorbed damage regardless of HP or MP type. This
# does not affect undead.
#
# <death on hp dmg>, <death on mp dmg>
# If dealt any HP or MP damage (for the respective tags, the affected battler
# will die instantly (or if the battler is immortal, HP dropped to 0).
#
# <death on hp heal>, <death on mp heal>
# Similar to the above, if healed for HP or MP, the affected battler will die
# instantly (or if the battler is immortal, HP will be dropped to 0).
#
# ------------------------------------------------------------
# The following are mods that affect damage taken.
# ------------------------------------------------------------
#
# <hp pain rate x>, <hp heal rate x>
# This raises or lowers the amount of HP damage or healing the battler will
# take in. This is calculated above the rest of the HP modifying attributes.
# <<STACKABLE>>
#
# <super armour>
# Reduces damage dealt to character by adjustable values down below. Super
# does not reduce damage dealt to the character outside of the normal battle
# mechanics and directly adjusting character HP.
#
# <invincible hp>
# When a character is invincible, that character cannot take HP damage at all.
# The character can still die via directly applying the death status and will
# still take HP degen damage. Use with <immortality> if you want an unkillable
# and undamagable status effect.
#
# <hpdmg to mpdmg x>
# Shifts x percent of HP damage over to MP damage. All of this occurs after the
# react effects and HP damage reductions. If there isn't enough MP, it'll go
# back to HP for remaining damage. Both HP and MP damage will show.
#
# <undead hp x>
# If the target's HP is to be healed, that recovery is converted into damage.
# x is the percentage of the damage dealt. For example, if a battler is to be
# healed for 100, <undead hp 80> would make the battler take 80 damage with no
# HP recovered. <undead hp 100> would allow for 100% conversion. This ignores
# any kind of super armour and invincible HP properties. This also prevents
# absorption for both HP and MP.
#
# <mp pain rate x>, <mp heal rate x>
# This raises or lowers the amount of MP damage or healing the battler will
# take in. This is calculated above the rest of the MP modifying attributes.
# <<STACKABLE>>
#
# <super barrier>
# Functions similar to super armour, but reduces MP damage instead. Does not
# reduce MP damage dealt to character outside of normal battle mechanics and
# directly adjusting character MP.
#
# <invincible mp>
# Just like the effect for its HP counterpart, this prevents any MP damage at
# all if dealt. This does not protect against manually lowering MP and skills
# that cost MP will still lower MP.
#
# <mpdmg to hpdmg x>
# Pretty much the opposite of its HP counterpart, this will convert a percent of
# any potential MP damage to HP damage. This will not kill the battler, but will
# leave the battler at 1 HP minimum.
#
# <undead mp x>
# Similar to <undead hp x>, this converts MP recovery into MP damage by x
# percentage. For example, if the battler is to be healed for 100 MP, the tag
# <undead mp 75> would make the battler take 75 MP damage instead. This ignores
# any super barrier and invincible MP properties. This also prevents absorption
# for both HP and MP.
#
#===============================================================================
#
# Compatibility
# - Works With: KGC LimitBreak
# - Alias: Game_Battler, initialize, maxhp, maxmp, atk, def, spi, agi
# - Alias: Game_Battler, add_state, remove_state, remove_states_auto
# - Alias: Game_Battler, execute_damage, slip_damage_effect
# - Alias: Game_Actor, hit, eva, cri, odds, a lot of equip traits
# - Alias: Game_Enemy, hit, eva, cri, odds
# - Alias: Scene_Battle, start
# - Overwrites: Game_Actor, state_probability
# - Overwrites: Game_Enemy, state_probability
#
#===============================================================================
$imported = {} if $imported == nil
$imported["CustomStatusProperties"] = true
module YE
module BATTLE
# This part allows you to quickly change the state probability success
# rate rankings without needing to do too much in the core script.
STATE_A = 100
STATE_B = 80
STATE_C = 60
STATE_D = 40
STATE_E = 20
STATE_F = 0
# These values determine how much HP damage that status effects with the
# super armour property reduces HP damage by.
SUPER_ARMOUR_PER = 90 # Reduces HP damage by 90%.
SUPER_ARMOUR_SUB = 50 # Reduces HP damage by 50 HP.
SUPER_ARMOUR_MIN = 1 # Minimum HP damage given to super armour.
# These values determine how much MP damage that status effects with the
# super barrier property reduces MP damage by.
SUPER_BARRIER_PER = 80 # Reduces MP damage by 80%.
SUPER_BARRIER_SUB = 10 # Reduces MP damage by 10 MP.
SUPER_BARRIER_MIN = 1 # Minimum MP damage given to the super barrier.
end #module BATTLE
module HASH
# This part is entirely optional, but it helps categorize status effects
# if you ever decide to clump them together in mass. I do this since it's
# easier to find if a state belongs to a certain collection of elements.
STATE_TYPE = { # Input the states into any category you want here.
"Death" => [ 1],
"Conditions" => [ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
"Buffs" => [ 9, 10, 11, 12],
"Debuffs" => [13, 14, 15, 16],
} # Do not remove this
end #module HASH
end #module YE
#===============================================================================
# How to Use: Lunatic Mode
#===============================================================================
#
# This section is for all the lunatic scripters out there who want to do a bit
# more with your status effects. Put these into your status effect's notebox
# and then head over to the next section to script your own custom effects.
#
# <apply effect x>
# Apply effects occur whenever states are added to the battler. These also
# trigger from the event editor. Find "run_apply_effect" to script your own
# custom effects.
#
# <begin effect x>
# Begin effects occur at the start of a turn. These will always trigger so long
# as the state exists on the battler. Find "run_begin_effect" to script your
# own begin effects.
#
# <while effect x>
# While effects occur each turn after the battler performs an action. These
# do not trigger from the event editor and do not trigger if the battler is
# vanished. Find "run_while_effect" to script your own custom effects.
#
# <react effect x>
# React effects occur whenever the battler is the target of an attack or skill.
# The effect does not trigger if it's just a script dealing damage to it without
# an attack or skill base. Find "run_react_effect" to script your own effects.
# Be careful about scripting react effects to cause damage since it can make an
# endless chain of react effects. Apply anti_react if needed.
#
# <shock effect x>
# Shock effects after the battler has finished taking an attack unlike the react
# effect where it triggers before an attack. Find "run_shock_effect" to script
# your own shock effects.
#
# <close effect x>
# Close effects occur at the end of a turn. These will always trigger so long
# as the state exists on the battler. Find "run_close_effect" to script your
# own close effects.
#
# <leave effect x>
# Leave effects occur if the status effect leaves naturally after the turn
# limit is up. These won't trigger if you manually erase them. Erase effects
# will still occur even after a leave effect. Find "run_leave_effect" to script
# your own custom effects.
#
# <erase effect x>
# Erase effects occur whenever states are removed from the battler. Like the
# apply effects, these trigger with the event editor. Find "run_erase_effect"
# to script your own custom effects.
#
# ------------------------------------------------------------------------------
# There are functions unique to this script for Game_Battler:
# ------------------------------------------------------------------------------
# msgwait
# Causes $scene_battle to wait 30 frames. If you want it to wait more, change
# it to msgwait(x) where x is the frames you want it to wait.
#
# status_damage(hp_dmg, mp_dmg, target, attacker, anti_react = true,
# absorb = false)
# This allows you to damage the target and display it properly with death
# animations and all if you decide for that to be the custom effect. Set the
# anti_react flag to true (it's true by default) to prevent endless react
# chains and potentially put your game into an endless loop.
#
# set_state_turns(state_id, new_turns)
# This allows you to manually adjust the state's turns. Note that if you set
# it to zero or lower, it'll be readjusted to 1 to prevent bugs.
#
# state_turns?(state_id)
# This returns whatever number of turns is left for the state.
#
#===============================================================================
class Game_Battler
def run_apply_effect(state)
state_effect_id = state.apply_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state apply effects
#---------------------------------------------------------------------------
when 1
self.hp = self.mp
text = sprintf("%s's HP becomes %s's MP!", self.name, self.name)
$message__window.add_instant_text(text)
msgwait
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_begin_effect(state)
state_effect_id = state.begin_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state apply effects
#---------------------------------------------------------------------------
when 1
text = "It's the start of the turn!"
$message__window.add_instant_text(text)
msgwait
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_while_effect(state)
state_effect_id = state.while_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state while effects
#---------------------------------------------------------------------------
when 1
self.hp += self.mp
text = sprintf("%s heals %d HP!", self.name, self.mp)
$message__window.add_instant_text(text)
msgwait
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_react_effect(state)
state_effect_id = state.react_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state react effects
#---------------------------------------------------------------------------
when 1
if @hp_damage > 0
self.add_state(9)
end
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_shock_effect(state)
state_effect_id = state.shock_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state shock effects
#---------------------------------------------------------------------------
when 1
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_close_effect(state)
state_effect_id = state.close_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state close effects
#---------------------------------------------------------------------------
when 1
text = "It's the end of the turn!"
$message__window.add_instant_text(text)
msgwait
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_leave_effect(state)
state_effect_id = state.leave_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state leave effects
#---------------------------------------------------------------------------
when 1
self.mp += self.maxmp / 2
text = sprintf("%s's recovers %d MP!", self.name, self.maxhp / 2)
$message__window.add_instant_text(text)
msgwait
when 2
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
def run_erase_effect(state)
state_effect_id = state.erase_effect
line_number = $message__window.line_number if $game_temp.in_battle
case state_effect_id
#---------------------------------------------------------------------------
# //////////////////////////////////////////////////////////////////////////
# This is where you begin adding in your own state erase effects
#---------------------------------------------------------------------------
when 1
self.hp = self.maxhp
text = sprintf("%s's HP becomes %d!", self.name, self.maxhp)
$message__window.add_instant_text(text)
msgwait
when 2
text = "A poisonous gas appears!"
$message__window.add_instant_text(text)
$scene.display_animation($game_troop.existing_members, 31)
$scene.wait_for_animation
mini_line = $message__window.line_number
hpdmg = self.atk + self.spi
for member in self.action.opponents_unit.existing_members
status_damage(hpdmg, 0, member, self, true, true)
$message__window.back_to(mini_line)
end
#---------------------------------------------------------------------------
# This is the part you guys shouldn't touch afterwards.
# //////////////////////////////////////////////////////////////////////////
#---------------------------------------------------------------------------
end
$message__window.back_to(line_number) if $game_temp.in_battle
end
end # Game_Battler
#===============================================================================
# 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 STATE
# These adjust State Stacking
MAX_STACK = /<(?:MAX_STACK|max stack)[ ]*(d+)>/i
# These adjust MaxHP and MaxMP.
MAXHP_PER = /<(?:MAXHP_PER|maxhp per)[ ]*(d+)>/i
MAXMP_PER = /<(?:MAXMP_PER|maxmp per)[ ]*(d+)>/i
MAXHP_ADD = /<(?:MAXHP_ADD|maxhp add)[ ]*(d+)>/i
MAXMP_ADD = /<(?:MAXMP_ADD|maxmp add)[ ]*(d+)>/i
MAXHP_SUB = /<(?:MAXHP_SUB|maxhp sub)[ ]*(d+)>/i
MAXMP_SUB = /<(?:MAXMP_SUB|maxmp sub)[ ]*(d+)>/i
# These adjust Attack, Defense, Spirit, and Agility.
ATK_PER = /<(?:NEW_ATK_RATE|new atk rate|ATK_PER|atk per)[ ]*(d+)>/i
DEF_PER = /<(?:NEW_DEF_RATE|new def rate|DEF_PER|def per)[ ]*(d+)>/i
SPI_PER = /<(?:NEW_SPI_RATE|new spi rate|SPI_PER|spi per)[ ]*(d+)>/i
AGI_PER = /<(?:NEW_AGI_RATE|new agi rate|AGI_PER|agi per)[ ]*(d+)>/i
ATK_ADD = /<(?:ATK_ADD|atk add)[ ]*(d+)>/i
DEF_ADD = /<(?:DEF_ADD|def add)[ ]*(d+)>/i
SPI_ADD = /<(?:SPI_ADD|spi add)[ ]*(d+)>/i
AGI_ADD = /<(?:AGI_ADD|agi add)[ ]*(d+)>/i
ATK_SUB = /<(?:ATK_SUB|atk sub)[ ]*(d+)>/i
DEF_SUB = /<(?:DEF_SUB|def sub)[ ]*(d+)>/i
SPI_SUB = /<(?:SPI_SUB|spi sub)[ ]*(d+)>/i
AGI_SUB = /<(?:AGI_SUB|agi sub)[ ]*(d+)>/i
# These adjust Hit, Evasion, Critical, and Odds
if $imported["LimitBreak"]
HECOLIMIT = KGC::LimitBreak::ACTOR_PARAMETER_LIMIT
else
HECOLIMIT = 999
end
HIT_PER = /<(?:HIT_PER|hit per)[ ]*(d+)>/i
HIT_ADD = /<(?:HIT_ADD|hit add)[ ]*(d+)>/i
HIT_SUB = /<(?:HIT_SUB|hit sub)[ ]*(d+)>/i
EVA_PER = /<(?:EVA_PER|eva per)[ ]*(d+)>/i
EVA_ADD = /<(?:EVA_ADD|eva add)[ ]*(d+)>/i
EVA_SUB = /<(?:EVA_SUB|eva sub)[ ]*(d+)>/i
CRI_PER = /<(?:CRI_PER|cri per)[ ]*(d+)>/i
CRI_ADD = /<(?:CRI_ADD|cri add)[ ]*(d+)>/i
CRI_SUB = /<(?:CRI_SUB|cri sub)[ ]*(d+)>/i
ODDS_PER = /<(?:ODDS_PER|odds per)[ ]*(d+)>/i
ODDS_ADD = /<(?:ODDS_ADD|odds add)[ ]*(d+)>/i
ODDS_SUB = /<(?:ODDS_SUB|odds sub)[ ]*(d+)>/i
# These adjust HP/MP Degen and Regen.
HP_DEGEN_PER = /<(?:HP_DEGEN_PER|hp degen per)[ ]*(d+)>/i
HP_DEGEN_SET = /<(?:HP_DEGEN_SET|hp degen set)[ ]*(d+)>/i
HP_REGEN_PER = /<(?:HP_REGEN_PER|hp regen per)[ ]*(d+)>/i
HP_REGEN_SET = /<(?:HP_REGEN_SET|hp regen set)[ ]*(d+)>/i
MP_DEGEN_PER = /<(?:MP_DEGEN_PER|mp degen per)[ ]*(d+)>/i
MP_DEGEN_SET = /<(?:MP_DEGEN_SET|mp degen set)[ ]*(d+)>/i
MP_REGEN_PER = /<(?:MP_REGEN_PER|mp regen per)[ ]*(d+)>/i
MP_REGEN_SET = /<(?:MP_REGEN_SET|mp regen set)[ ]*(d+)>/i
# These are the unique effects.
IMMORTALITY = /<(?:IMMORTALITY|immortality)>/i
VANISH = /<(?:VANISH|vanish)>/i
AUTO_BATTLE = /<(?:AUTO_BATTLE|auto battle)>/i
HALF_MP_COST = /<(?:HALF_MP_COST|half mp cost)>/i
SUPER_GUARD = /<(?:SUPER_GUARD|super guard)>/i
PHARMA = /<(?:PHARMACOLOGY|pharmacology)>/i
DOUBLE_EXP = /<(?:DOUBLE_EXP_GAIN|double exp gain)>/i
FAST_ATTACK = /<(?:FAST_ATTACK|fast attack)>/i
PREVENT_CRIT = /<(?:PREVENT_CRITICAL|prevent critical)>/i
ANTI_STATE = /<(?:ANTI_STATE|anti state)>/i
ABSORB_HP = /<(?:ABSORB_HP|absorb hp)>/i
ABSORB_MP = /<(?:ABSORB_MP|absorb mp)>/i
DEATH_HPDMG = /<(?:DEATH_ON_HP_DMG|death on hp dmg)>/i
DEATH_MPDMG = /<(?:DEATH_ON_MP_DMG|death on mp dmg)>/i
DEATH_HPHEAL = /<(?:DEATH_ON_HP_HEAL|death on hp heal)>/i
DEATH_MPHEAL = /<(?:DEATH_ON_MP_HEAL|death on mp heal)>/i
# This affects damage taken.
HP_PAIN_RATE = /<(?:HP_PAIN_RATE|hp pain rate[ ]*(d+))>/i
HP_HEAL_RATE = /<(?:HP_HEAL_RATE|hp heal rate[ ]*(d+))>/i
MP_PAIN_RATE = /<(?:MP_PAIN_RATE|mp pain rate[ ]*(d+))>/i
MP_HEAL_RATE = /<(?:MP_HEAL_RATE|mp heal rate[ ]*(d+))>/i
UNDEAD_HP = /<(?:UNDEAD_HP|undead hp[ ]*(d+))>/i
UNDEAD_MP = /<(?:UNDEAD_MP|undead mp[ ]*(d+))>/i
SUPER_ARMOUR = /<(?:SUPER_ARMOUR|super armour|super armor)>/i
SUPER_BARRIER = /<(?:SUPER_BARRIER|super barrier)>/i
INVINCIBLE_HP = /<(?:INVINCIBLE_HP|invincibility_hp)>/i
INVINCIBLE_MP = /<(?:INVINCIBLE_MP|invincibility_mp)>/i
HPDMG_MPDMG = /<(?:HPDMG_TO_MPDMG|hpdmg to mpdmg[ ]*(d+))>/i
MPDMG_HPDMG = /<(?:MPDMG_TO_HPDMG|mpdmg to hpdmg[ ]*(d+))>/i
# These here are the custom state effects.
APPLY_EFFECT = /<(?:APPLY_EFFECT|apply effect)[ ]*(d+)>/i
WHILE_EFFECT = /<(?:WHILE_EFFECT|while effect)[ ]*(d+)>/i
LEAVE_EFFECT = /<(?:LEAVE_EFFECT|leave effect)[ ]*(d+)>/i
ERASE_EFFECT = /<(?:ERASE_EFFECT|erase effect)[ ]*(d+)>/i
REACT_EFFECT = /<(?:REACT_EFFECT|react effect)[ ]*(d+)>/i
SHOCK_EFFECT = /<(?:SHOCK_EFFECT|shock effect)[ ]*(d+)>/i
CLOSE_EFFECT = /<(?:CLOSE_EFFECT|close effect)[ ]*(d+)>/i
BEGIN_EFFECT = /<(?:BEGIN_EFFECT|begin effect)[ ]*(d+)>/i
end #module STATE
end # module REGEXP
end # module YE
#===============================================================================
# RPG::State
#===============================================================================
class RPG::State
#--------------------------------------------------------------------------
# Yanfly_Cache_CSP
#--------------------------------------------------------------------------
def yanfly_cache_csp
@maxhp_per = 100; @maxhp_set = 0; @maxmp_per = 100; @maxmp_set = 0
@atk_per = 100; @def_per = 100; @spi_per = 100; @agi_per = 100
@atk_set = 0; @def_set = 0; @spi_set = 0; @agi_set = 0
@hit_per = 100; @hit_set = 0; @eva_per = 100; @eva_set = 0
@cri_per = 100; @cri_set = 0; @odds_per = 100; @odds_set = 0
@apply_effect = 0; @while_effect = 0; @leave_effect = 0; @erase_effect = 0
@react_effect = 0; @half_mp_cost = false; @super_guard = false
@hp_degen_per = 0; @hp_degen_set = 0; @hp_regen_per = 0; @hp_regen_set = 0
@mp_degen_per = 0; @mp_degen_set = 0; @mp_regen_per = 0; @mp_regen_set = 0
@immortality = false; @vanish = false; @auto_battle = false;
@pharmacology = false; @double_exp_gain = false; @fast_attack = false
@prevent_critical = false; @anti_state = false; @super_armour = false
@absorb_hp = false; @absorb_mp = false; @super_barrier = false
@invincible_hp = false; @invincible_mp = false; @hpdmg_mpdmg = 0;
@mpdmg_hpdmg = 0; @undead_hp = 0; @undead_mp = 0; @death_hpdmg = false;
@death_mpdmg = false; @death_hpheal = false; @death_mpheal = false;
@hp_pain_rate = 0; @mp_pain_rate = 0; @hp_heal_rate = 0; @mp_heal_rate = 0
@max_stack = 1; @shock_effect = 0; @close_effect = 0; @begin_effect = 0
self.note.split(/[rn]+/).each { |line|
case line
when YE::REGEXP::STATE::MAX_STACK
@max_stack = $1.to_i
when YE::REGEXP::STATE::MAXHP_PER
@maxhp_per = $1.to_i
when YE::REGEXP::STATE::MAXHP_ADD
@maxhp_set = $1.to_i
when YE::REGEXP::STATE::MAXHP_SUB
@maxhp_set = $1.to_i * -1
when YE::REGEXP::STATE::MAXMP_PER
@maxmp_per = $1.to_i
when YE::REGEXP::STATE::MAXMP_ADD
@maxmp_set = $1.to_i
when YE::REGEXP::STATE::MAXMP_SUB
@maxmp_set = $1.to_i * -1
when YE::REGEXP::STATE::ATK_PER
@atk_per = $1.to_i
when YE::REGEXP::STATE::ATK_ADD
@atk_set = $1.to_i
when YE::REGEXP::STATE::ATK_SUB
@atk_set = $1.to_i * -1
when YE::REGEXP::STATE::DEF_PER
@def_per = $1.to_i
when YE::REGEXP::STATE::DEF_ADD
@def_set = $1.to_i
when YE::REGEXP::STATE::DEF_SUB
@def_set = $1.to_i * -1
when YE::REGEXP::STATE::SPI_PER
@spi_per = $1.to_i
when YE::REGEXP::STATE::SPI_ADD
@spi_set = $1.to_i
when YE::REGEXP::STATE::SPI_SUB
@spi_set = $1.to_i
when YE::REGEXP::STATE::AGI_PER
@agi_per = $1.to_i
when YE::REGEXP::STATE::AGI_ADD
@agi_set = $1.to_i
when YE::REGEXP::STATE::AGI_SUB
@agi_set = $1.to_i * -1
when YE::REGEXP::STATE::HIT_PER
@hit_per = $1.to_i
when YE::REGEXP::STATE::HIT_ADD
@hit_set = $1.to_i
when YE::REGEXP::STATE::HIT_SUB
@hit_set = $1.to_i * -1
when YE::REGEXP::STATE::EVA_PER
@eva_per = $1.to_i
when YE::REGEXP::STATE::EVA_ADD
@eva_set = $1.to_i
when YE::REGEXP::STATE::EVA_SUB
@eva_set = $1.to_i * -1
when YE::REGEXP::STATE::CRI_PER
@cri_per = $1.to_i
when YE::REGEXP::STATE::CRI_ADD
@cri_set = $1.to_i
when YE::REGEXP::STATE::CRI_SUB
@cri_set = $1.to_i * -1
when YE::REGEXP::STATE::ODDS_PER
@odds_per = $1.to_i
when YE::REGEXP::STATE::ODDS_ADD
@odds_set = $1.to_i
when YE::REGEXP::STATE::ODDS_SUB
@odds_set = $1.to_i * -1
when YE::REGEXP::STATE::APPLY_EFFECT
@apply_effect = $1.to_i
when YE::REGEXP::STATE::WHILE_EFFECT
@while_effect = $1.to_i
when YE::REGEXP::STATE::LEAVE_EFFECT
@leave_effect = $1.to_i
when YE::REGEXP::STATE::ERASE_EFFECT
@erase_effect = $1.to_i
when YE::REGEXP::STATE::REACT_EFFECT
@react_effect = $1.to_i
when YE::REGEXP::STATE::SHOCK_EFFECT
@shock_effect = $1.to_i
when YE::REGEXP::STATE::CLOSE_EFFECT
@close_effect = $1.to_i
when YE::REGEXP::STATE::BEGIN_EFFECT
@begin_effect = $1.to_i
when YE::REGEXP::STATE::HP_DEGEN_PER
@hp_degen_per = $1.to_i
when YE::REGEXP::STATE::HP_DEGEN_SET
@hp_degen_set = $1.to_i
when YE::REGEXP::STATE::HP_REGEN_PER
@hp_regen_per = $1.to_i
when YE::REGEXP::STATE::HP_REGEN_SET
@hp_regen_set = $1.to_i
when YE::REGEXP::STATE::MP_DEGEN_PER
@mp_degen_per = $1.to_i
when YE::REGEXP::STATE::MP_DEGEN_SET
@mp_degen_set = $1.to_i
when YE::REGEXP::STATE::MP_REGEN_PER
@mp_regen_per = $1.to_i
when YE::REGEXP::STATE::MP_REGEN_SET
@mp_regen_set = $1.to_i
when YE::REGEXP::STATE::IMMORTALITY
@immortality = true
when YE::REGEXP::STATE::VANISH
@vanish = true
when YE::REGEXP::STATE::AUTO_BATTLE
@auto_battle = true
when YE::REGEXP::STATE::HALF_MP_COST
@half_mp_cost = true
when YE::REGEXP::STATE::SUPER_GUARD
@super_guard = true
when YE::REGEXP::STATE::PHARMA
@pharmacology = true
when YE::REGEXP::STATE::DOUBLE_EXP
@double_exp_gain = true
when YE::REGEXP::STATE::FAST_ATTACK
@fast_attack = true
when YE::REGEXP::STATE::PREVENT_CRIT
@prevent_critical = true
when YE::REGEXP::STATE::ANTI_STATE
@anti_state = true
when YE::REGEXP::STATE::ABSORB_HP
@absorb_hp = true
when YE::REGEXP::STATE::ABSORB_MP
@absorb_mp = true
when YE::REGEXP::STATE::SUPER_ARMOUR
@super_armour = true
when YE::REGEXP::STATE::SUPER_BARRIER
@super_barrier = true
when YE::REGEXP::STATE::INVINCIBLE_HP
@invincible_hp = true
when YE::REGEXP::STATE::INVINCIBLE_MP
@invincible_mp = true
when YE::REGEXP::STATE::HPDMG_MPDMG
@hpdmg_mpdmg = $1.to_i
@hpdmg_mpdmg = 100 if @hpdmg_mpdmg > 100
when YE::REGEXP::STATE::MPDMG_HPDMG
@mpdmg_hpdmg = $1.to_i
@mpdmg_hpdmg = 100 if @mpdmg_hpdmg > 100
when YE::REGEXP::STATE::UNDEAD_HP
@undead_hp = $1.to_i
when YE::REGEXP::STATE::UNDEAD_MP
@undead_mp = $1.to_i
when YE::REGEXP::STATE::DEATH_HPDMG
@death_hpdmg = true
when YE::REGEXP::STATE::DEATH_MPDMG
@death_mpdmg = true
when YE::REGEXP::STATE::DEATH_HPHEAL
@death_hpheal = true
when YE::REGEXP::STATE::DEATH_MPHEAL
@death_mpheal = true
when YE::REGEXP::STATE::HP_PAIN_RATE
@hp_pain_rate = $1.to_i
when YE::REGEXP::STATE::MP_PAIN_RATE
@mp_pain_rate = $1.to_i
when YE::REGEXP::STATE::HP_HEAL_RATE
@hp_heal_rate = $1.to_i
when YE::REGEXP::STATE::MP_HEAL_RATE
@mp_heal_rate = $1.to_i
end
}
end # end yanfly_cache_csp
#--------------------------------------------------------------------------
# max stack
#--------------------------------------------------------------------------
def max_stack
yanfly_cache_csp if @max_stack == nil
return @max_stack
end
#--------------------------------------------------------------------------
# maxhp mods
#--------------------------------------------------------------------------
def maxhp_per
yanfly_cache_csp if @maxhp_per == nil
return @maxhp_per
end
def maxhp_set
yanfly_cache_csp if @maxhp_set == nil
return @maxhp_set
end
#--------------------------------------------------------------------------
# maxmp mods
#--------------------------------------------------------------------------
def maxmp_per
yanfly_cache_csp if @maxmp_per == nil
return @maxmp_per
end
def maxmp_set
yanfly_cache_csp if @maxmp_set == nil
return @maxmp_set
end
#--------------------------------------------------------------------------
# New Stat Rates
#--------------------------------------------------------------------------
def atk_per
yanfly_cache_csp if @atk_per == nil
return @atk_per
end
def def_per
yanfly_cache_csp if @def_per == nil
return @def_per
end
def spi_per
yanfly_cache_csp if @spi_per == nil
return @spi_per
end
def agi_per
yanfly_cache_csp if @agi_per == nil
return @agi_per
end
def atk_set
yanfly_cache_csp if @atk_set == nil
return @atk_set
end
def def_set
yanfly_cache_csp if @def_set == nil
return @def_set
end
def spi_set
yanfly_cache_csp if @spi_set == nil
return @spi_set
end
def agi_set
yanfly_cache_csp if @agi_set == nil
return @agi_set
end
#--------------------------------------------------------------------------
# Hit, Eva, Cri, Odds
#--------------------------------------------------------------------------
def hit_per
yanfly_cache_csp if @hit_per == nil
return @hit_per
end
def hit_set
yanfly_cache_csp if @hit_set == nil
return @hit_set
end
def eva_per
yanfly_cache_csp if @eva_per == nil
return @eva_per
end
def eva_set
yanfly_cache_csp if @eva_set == nil
return @eva_set
end
def cri_per
yanfly_cache_csp if @cri_per == nil
return @cri_per
end
def cri_set
yanfly_cache_csp if @cri_set == nil
return @cri_set
end
def odds_per
yanfly_cache_csp if @odds_per == nil
return @odds_per
end
def odds_set
yanfly_cache_csp if @odds_set == nil
return @odds_set
end
#--------------------------------------------------------------------------
# Custom Apply Effect
#--------------------------------------------------------------------------
def apply_effect
yanfly_cache_csp if @apply_effect == nil
return @apply_effect
end
#--------------------------------------------------------------------------
# Custom While Effect
#--------------------------------------------------------------------------
def while_effect
yanfly_cache_csp if @while_effect == nil
return @while_effect
end
#--------------------------------------------------------------------------
# Custom Leave Effect
#--------------------------------------------------------------------------
def leave_effect
yanfly_cache_csp if @leave_effect == nil
return @leave_effect
end
#--------------------------------------------------------------------------
# Custom Erase Effect
#--------------------------------------------------------------------------
def erase_effect
yanfly_cache_csp if @erase_effect == nil
return @erase_effect
end
#--------------------------------------------------------------------------
# Custom React Effect
#--------------------------------------------------------------------------
def react_effect
yanfly_cache_csp if @react_effect == nil
return @react_effect
end
#--------------------------------------------------------------------------
# Custom Shock Effect
#--------------------------------------------------------------------------
def shock_effect
yanfly_cache_csp if @shock_effect == nil
return @shock_effect
end
#--------------------------------------------------------------------------
# Custom Close Effect
#--------------------------------------------------------------------------
def close_effect
yanfly_cache_csp if @close_effect == nil
return @close_effect
end
#--------------------------------------------------------------------------
# Custom Begin Effect
#--------------------------------------------------------------------------
def begin_effect
yanfly_cache_csp if @begin_effect == nil
return @begin_effect
end
#--------------------------------------------------------------------------
# HP Degen/Regen
#--------------------------------------------------------------------------
def hp_degen_per
yanfly_cache_csp if @hp_degen_per == nil
return @hp_degen_per
end
def hp_degen_set
yanfly_cache_csp if @hp_degen_set == nil
return @hp_degen_set
end
def hp_regen_per
yanfly_cache_csp if @hp_regen_per == nil
return @hp_regen_per
end
def hp_regen_set
yanfly_cache_csp if @hp_regen_set == nil
return @hp_regen_set
end
def dr_hp?
return true if hp_degen_per > 0
return true if hp_regen_per > 0
return true if hp_degen_set > 0
return true if hp_regen_set > 0
end
#--------------------------------------------------------------------------
# MP Degen/Regen
#--------------------------------------------------------------------------
def mp_degen_per
yanfly_cache_csp if @mp_degen_per == nil
return @mp_degen_per
end
def mp_degen_set
yanfly_cache_csp if @mp_degen_set == nil
return @mp_degen_set
end
def mp_regen_per
yanfly_cache_csp if @mp_regen_per == nil
return @mp_regen_per
end
def mp_regen_set
yanfly_cache_csp if @mp_regen_set == nil
return @mp_regen_set
end
def dr_mp?
return true if mp_degen_per > 0
return true if mp_regen_per > 0
return true if mp_degen_set > 0
return true if mp_regen_set > 0
end
#--------------------------------------------------------------------------
# Immortality
#--------------------------------------------------------------------------
def immortality
yanfly_cache_csp if @immortality == nil
return @immortality
end
#--------------------------------------------------------------------------
# Vanish
#--------------------------------------------------------------------------
def vanish
yanfly_cache_csp if @vanish == nil
return @vanish
end
#--------------------------------------------------------------------------
# Auto Battle
#--------------------------------------------------------------------------
def auto_battle
yanfly_cache_csp if @auto_battle == nil
return @auto_battle
end
#--------------------------------------------------------------------------
# Half MP Cost
#--------------------------------------------------------------------------
def half_mp_cost
yanfly_cache_csp if @half_mp_cost == nil
return @half_mp_cost
end
#--------------------------------------------------------------------------
# Super Guard
#--------------------------------------------------------------------------
def super_guard
yanfly_cache_csp if @super_guard == nil
return @super_guard
end
#--------------------------------------------------------------------------
# Pharmacology
#--------------------------------------------------------------------------
def pharmacology
yanfly_cache_csp if @pharmacology == nil
return @pharmacology
end
#--------------------------------------------------------------------------
# Double EXP Gain
#--------------------------------------------------------------------------
def double_exp_gain
yanfly_cache_csp if @double_exp_gain == nil
return @double_exp_gain
end
#--------------------------------------------------------------------------
# Fast Attack
#--------------------------------------------------------------------------
def fast_attack
yanfly_cache_csp if @fast_attack == nil
return @fast_attack
end
#--------------------------------------------------------------------------
# Prevent Critical
#--------------------------------------------------------------------------
def prevent_critical
yanfly_cache_csp if @prevent_critical == nil
return @prevent_critical
end
#--------------------------------------------------------------------------
# Anti State
#--------------------------------------------------------------------------
def anti_state
yanfly_cache_csp if @anti_state == nil
return @anti_state
end
#--------------------------------------------------------------------------
# Absorb HP/MP
#--------------------------------------------------------------------------
def absorb_hp
yanfly_cache_csp if @absorb_hp == nil
return @absorb_hp
end
def absorb_mp
yanfly_cache_csp if @absorb_mp == nil
return @absorb_mp
end
#--------------------------------------------------------------------------
# super_armour
#--------------------------------------------------------------------------
def super_armour
yanfly_cache_csp if @super_armour == nil
return @super_armour
end
#--------------------------------------------------------------------------
# super_barrier
#--------------------------------------------------------------------------
def super_barrier
yanfly_cache_csp if @super_barrier == nil
return @super_barrier
end
#--------------------------------------------------------------------------
# invincible_hp
#--------------------------------------------------------------------------
def invincible_hp
yanfly_cache_csp if @invincible_hp == nil
return @invincible_hp
end
#--------------------------------------------------------------------------
# invincible_mp
#--------------------------------------------------------------------------
def invincible_mp
yanfly_cache_csp if @invincible_mp == nil
return @invincible_mp
end
#--------------------------------------------------------------------------
# HP Damage to MP Damage
#--------------------------------------------------------------------------
def hpdmg_mpdmg
yanfly_cache_csp if @hpdmg_mpdmg == nil
return @hpdmg_mpdmg
end
#--------------------------------------------------------------------------
# MP Damage to HP Damage
#--------------------------------------------------------------------------
def mpdmg_hpdmg
yanfly_cache_csp if @mpdmg_hpdmg == nil
return @mpdmg_hpdmg
end
#--------------------------------------------------------------------------
# Undead HP/MP
#--------------------------------------------------------------------------
def undead_hp
yanfly_cache_csp if @undead_hp == nil
return @undead_hp
end
def undead_mp
yanfly_cache_csp if @undead_mp == nil
return @undead_mp
end
#--------------------------------------------------------------------------
# death on hp/mp damage/heal
#--------------------------------------------------------------------------
def death_hpdmg
yanfly_cache_csp if @death_hpdmg == nil
return @death_hpdmg
end
def death_mpdmg
yanfly_cache_csp if @death_mpdmg == nil
return @death_mpdmg
end
def death_hpheal
yanfly_cache_csp if @death_hpheal == nil
return @death_hpheal
end
def death_mpheal
yanfly_cache_csp if @death_mpheal == nil
return @death_mpheal
end
#--------------------------------------------------------------------------
# HP/MP Pain/Heal Rate
#--------------------------------------------------------------------------
def hp_pain_rate
yanfly_cache_csp if @hp_pain_rate == nil
return @hp_pain_rate
end
def mp_pain_rate
yanfly_cache_csp if @mp_pain_rate == nil
return @mp_pain_rate
end
def hp_heal_rate
yanfly_cache_csp if @hp_heal_rate == nil
return @hp_heal_rate
end
def mp_heal_rate
yanfly_cache_csp if @mp_heal_rate == nil
return @mp_heal_rate
end
end #end RPG::State
#===============================================================================
# Game_Actor
#===============================================================================
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# alias auto_battle
#--------------------------------------------------------------------------
alias auto_battle_csp auto_battle unless $@
def auto_battle
for state in states
return true if state.auto_battle
end
return auto_battle_csp
end
#--------------------------------------------------------------------------
# alias half_mp_cost
#--------------------------------------------------------------------------
alias half_mp_cost_csp half_mp_cost unless $@
def half_mp_cost
for state in states
return true if state.half_mp_cost
end
return half_mp_cost_csp
end
#--------------------------------------------------------------------------
# alias super_guard
#--------------------------------------------------------------------------
alias super_guard_csp super_guard unless $@
def super_guard
for state in states
return true if state.super_guard
end
return super_guard_csp
end
#--------------------------------------------------------------------------
# alias pharmacology
#--------------------------------------------------------------------------
alias pharmacology_csp pharmacology unless $@
def pharmacology
for state in states
return true if state.pharmacology
end
return pharmacology_csp
end
#--------------------------------------------------------------------------
# alias double_exp_gain
#--------------------------------------------------------------------------
alias double_exp_gain_csp double_exp_gain unless $@
def double_exp_gain
for state in states
return true if state.double_exp_gain
end
return double_exp_gain_csp
end
#--------------------------------------------------------------------------
# alias fast_attack
#--------------------------------------------------------------------------
alias fast_attack_csp fast_attack unless $@
def fast_attack
for state in states
return true if state.fast_attack
end
return fast_attack_csp
end
#--------------------------------------------------------------------------
# alias prevent_critical
#--------------------------------------------------------------------------
alias prevent_critical_csp prevent_critical unless $@
def prevent_critical
for state in states
return true if state.prevent_critical
end
return prevent_critical_csp
end
#--------------------------------------------------------------------------
# Added State Success Rate
#--------------------------------------------------------------------------
def state_probability(state_id)
if $data_states[state_id].nonresistance
return 100
else
a = YE::BATTLE::STATE_A
b = YE::BATTLE::STATE_B
c = YE::BATTLE::STATE_C
d = YE::BATTLE::STATE_D
e = YE::BATTLE::STATE_E
f = YE::BATTLE::STATE_F
rank = self.class.state_ranks[state_id]
return [0,a,b,c,d,e,f][rank]
end
end
#--------------------------------------------------------------------------
# alias hit/eva/cri/odds for actors
#--------------------------------------------------------------------------
alias hit_actor_csp hit unless $@
def hit
n = hit_actor_csp
states.each { |state|
id = state.id
n *= (state.hit_per + ((state.hit_per - 100) * state_stack(id))) / 100.0
n += state.hit_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 0].max, limit].min
return n
end
alias eva_actor_csp eva unless $@
def eva
n = eva_actor_csp
states.each { |state|
id = state.id
n *= (state.eva_per + ((state.eva_per - 100) * state_stack(id))) / 100.0
n += state.eva_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 0].max, limit].min
return n
end
alias cri_actor_csp cri unless $@
def cri
n = cri_actor_csp
states.each { |state|
id = state.id
n *= (state.cri_per + ((state.cri_per - 100) * state_stack(id))) / 100.0
n += state.cri_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 0].max, limit].min
return n
end
alias odds_actor_csp odds unless $@
def odds
n = odds_actor_csp
states.each { |state|
id = state.id
n *= (state.odds_per + ((state.odds_per - 100) * state_stack(id))) / 100.0
n += state.odds_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 1].max, limit].min
return n
end
end #Game_Actor
#==============================================================================
# Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# alias hit/eva/cri/odds for enemies
#--------------------------------------------------------------------------
alias hit_enemy_csp hit unless $@
def hit
n = hit_enemy_csp
states.each { |state|
id = state.id
n *= (state.hit_per + ((state.hit_per - 100) * state_stack(id))) / 100.0
n += state.hit_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 1].max, limit].min
return n
end
alias eva_enemy_csp eva unless $@
def eva
n = eva_enemy_csp
states.each { |state|
id = state.id
n *= (state.eva_per + ((state.eva_per - 100) * state_stack(id))) / 100.0
n += state.eva_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 1].max, limit].min
return n
end
alias cri_enemy_csp cri unless $@
def cri
n = cri_enemy_csp
states.each { |state|
id = state.id
n *= (state.cri_per + ((state.cri_per - 100) * state_stack(id))) / 100.0
n += state.cri_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 1].max, limit].min
return n
end
alias odds_enemy_csp odds unless $@
def odds
n = odds_enemy_csp
states.each { |state|
id = state.id
n *= (state.odds_per + ((state.odds_per - 100) * state_stack(id))) / 100.0
n += state.odds_set * (state_stack(id) + 1)
}
limit = YE::REGEXP::STATE::HECOLIMIT
n = [[Integer(n), 1].max, limit].min
return n
end
#--------------------------------------------------------------------------
# Overwrite State Probability
#--------------------------------------------------------------------------
def state_probability(state_id)
if $data_states[state_id].nonresistance
return 100
else
a = YE::BATTLE::STATE_A
b = YE::BATTLE::STATE_B
c = YE::BATTLE::STATE_C
d = YE::BATTLE::STATE_D
e = YE::BATTLE::STATE_E
f = YE::BATTLE::STATE_F
rank = enemy.state_ranks[state_id]
return [0,a,b,c,d,e,f][rank]
end
end
end # game_enemy
#===============================================================================
# Game_Battler
#===============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :state_stack # This affects state stacking.
#--------------------------------------------------------------------------
# state stack
#--------------------------------------------------------------------------
def state_stack(state_id)
@state_stack = {} if @state_stack == nil
@state_stack[state_id] = 0 if @state_stack[state_id] == nil
if @state_stack[state_id] > $data_states[state_id].max_stack - 1
@state_stack[state_id] = $data_states[state_id].max_stack - 1
end
@state_stack[state_id] = 0 if @state_stack[state_id] < 0
return @state_stack[state_id]
end
#--------------------------------------------------------------------------
# state stack up
#--------------------------------------------------------------------------
def state_stack_up(state_id, up = 1)
return unless self.state?(state_id)
@state_stack = {} if @state_stack == nil
@state_stack[state_id] = 0 if @state_stack[state_id] == nil
@state_stack[state_id] += up
end
#--------------------------------------------------------------------------
# reset state stack
#--------------------------------------------------------------------------
def reset_state_stack(state_id)
@state_stack = {} if @state_stack == nil
@state_stack[state_id] = 0
end
#--------------------------------------------------------------------------
# alias maxhp
#--------------------------------------------------------------------------
alias maxhp_csp maxhp unless $@
def maxhp
n = maxhp_csp
states.each { |state|
id = state.id
n *= (state.maxhp_per + ((state.maxhp_per - 100) * state_stack(id))) / 100.0
n += state.maxhp_set * (state_stack(id) + 1)
}
n = [[Integer(n), 1].max, maxhp_limit].min
@hp = n if @hp > n
return n
end
#--------------------------------------------------------------------------
# alias maxmp
#--------------------------------------------------------------------------
alias maxmp_csp maxmp unless $@
def maxmp
n = maxmp_csp
states.each { |state|
id = state.id
n *= (state.maxmp_per + ((state.maxmp_per - 100) * state_stack(id))) / 100.0
n += state.maxmp_set * (state_stack(id) + 1)
}
limit = (defined?(maxmp_limit) ? maxmp_limit : 9999)
n = [[Integer(n), 0].max, limit].min
@mp = n if @mp > n
return n
end
#--------------------------------------------------------------------------
# alias attack
#--------------------------------------------------------------------------
alias atk_csp atk unless $@
def atk
n = atk_csp
states.each { |state|
id = state.id
n /= state.atk_rate / 100.00
n *= (state.atk_rate + ((state.atk_rate - 100) * state_stack(id))) / 100.0
n *= (state.atk_per + ((state.atk_per - 100) * state_stack(id))) / 100.0
n += state.atk_set * (state_stack(id) + 1)
}
limit = (defined?(parameter_limit) ? parameter_limit : 999)
n = [[Integer(n), 1].max, limit].min
return n
end
#--------------------------------------------------------------------------
# alias defense
#--------------------------------------------------------------------------
alias def_csp def
def def
n = def_csp
states.each { |state|
id = state.id
n /= state.def_rate / 100.00
n *= (state.def_rate + ((state.def_rate - 100) * state_stack(id))) / 100.0
n *= (state.def_per + ((state.def_per - 100) * state_stack(id))) / 100.0
n += state.def_set * (state_stack(id) + 1)
}
limit = (defined?(parameter_limit) ? parameter_limit : 999)
n = [[Integer(n), 1].max, limit].min
return n
end
#--------------------------------------------------------------------------
# alias spirit
#--------------------------------------------------------------------------
alias spi_csp spi unless $@
def spi
n = spi_csp
states.each { |state|
id = state.id
n /= state.spi_rate / 100.00
n *= (state.spi_rate + ((state.spi_rate - 100) * state_stack(id))) / 100.0
n *= (state.spi_per + ((state.spi_per - 100) * state_stack(id))) / 100.0
n += state.spi_set * (state_stack(id) + 1)
}
limit = (defined?(parameter_limit) ? parameter_limit : 999)
n = [[Integer(n), 1].max, limit].min
return n
end
#--------------------------------------------------------------------------
# alias agility
#--------------------------------------------------------------------------
alias agi_csp agi unless $@
def agi
n = agi_csp
states.each { |state|
id = state.id
n /= state.agi_rate / 100.00
n *= (state.agi_rate + ((state.agi_rate - 100) * state_stack(id))) / 100.0
n *= (state.agi_per + ((state.agi_per - 100) * state_stack(id))) / 100.0
n += state.agi_set * (state_stack(id) + 1)
}
limit = (defined?(parameter_limit) ? parameter_limit : 999)
n = [[Integer(n), 1].max, limit].min
return n
end
#--------------------------------------------------------------------------
# absorb hp/mp
#--------------------------------------------------------------------------
def absorb_hp
for state in states
if state.absorb_hp
return true
end
end
return false
end
def absorb_mp
for state in states
if state.absorb_mp
return true
end
end
return false
end
#--------------------------------------------------------------------------
# death on hp/mp damage/heal
#--------------------------------------------------------------------------
def death_hpdmg
for state in states
if state.death_hpdmg
return true
end
end
return false
end
def death_mpdmg
for state in states
if state.death_mpdmg
return true
end
end
return false
end
def death_hpheal
for state in states
if state.death_hpheal
return true
end
end
return false
end
def death_mpheal
for state in states
if state.death_mpheal
return true
end
end
return false
end
#--------------------------------------------------------------------------
# alias super_guard
#--------------------------------------------------------------------------
alias super_guard_battler_csp super_guard unless $@
def super_guard
for state in states
return true if state.super_guard
end
return super_guard_battler_csp
end
#--------------------------------------------------------------------------
# alias half_mp_cost
#--------------------------------------------------------------------------
alias half_mp_cost_battler_csp half_mp_cost unless $@
def half_mp_cost
for state in states
return true if state.half_mp_cost
end
return half_mp_cost_battler_csp
end
#--------------------------------------------------------------------------
# alias fast_attack
#--------------------------------------------------------------------------
alias fast_attack_battler_csp fast_attack unless $@
def fast_attack
for state in states
return true if state.fast_attack
end
return fast_attack_battler_csp
end
#--------------------------------------------------------------------------
# alias prevent_critical
#--------------------------------------------------------------------------
alias prevent_critical_battler_csp prevent_critical unless $@
def prevent_critical
for state in states
return true if state.prevent_critical
end
return prevent_critical_battler_csp
end
#--------------------------------------------------------------------------
# anti_state
#--------------------------------------------------------------------------
def anti_state
for state in states
return true if state.anti_state
end
return false
end
#--------------------------------------------------------------------------
# overwrite apply_state_changes
#--------------------------------------------------------------------------
def apply_state_changes(obj)
plus = obj.plus_state_set
minus = obj.minus_state_set
for i in plus
next if state_resist?(i)
next if dead?
next if i == 1 and @immortal
if state?(i)
@remained_states.push(i)
state_stack_up(i) if rand(100) < state_probability(i)
next
end
if rand(100) < state_probability(i)
add_state(i)
@added_states.push(i)
end
end
for i in minus
next unless state?(i)
remove_state(i)
@removed_states.push(i)
end
for i in @added_states & @removed_states
@added_states.delete(i)
@removed_states.delete(i)
end
end
#--------------------------------------------------------------------------
# alias add state
#--------------------------------------------------------------------------
alias add_state_csp add_state unless $@
def add_state(state_id)
state = $data_states[state_id]
return if state == nil
return if state_ignore?(state_id)
return if self.anti_state
state_stack_up(state_id) if state?(state_id)
#---
add_state_csp(state_id)
#---
state = $data_states[state_id]
unless @hidden
run_apply_effect(state) if state.apply_effect > 0
end
apply_hidden(state) if state.vanish
@immortal = true if state.immortality
end
#--------------------------------------------------------------------------
# apply_hidden
#--------------------------------------------------------------------------
def apply_hidden(hidden_state)
@hidden = true
for state in states
if state != hidden_state
if state_turns?(state.id) != nil and state_turns?(state.id) > 0
remove_state(state.id)
end
end
end
@hidden = true
end
#--------------------------------------------------------------------------
# alias remove state
#--------------------------------------------------------------------------
alias remove_state_csp remove_state unless $@
def remove_state(state_id)
reset_state_stack(state_id)
remove_state_csp(state_id)
state = $data_states[state_id]
#---
unless @hidden
run_erase_effect(state) if state.erase_effect > 0
end
#---
if state.immortality
remove_immortal = false
for state in states
remove_immortal = true if state.immortality
break if state.immortality
end
@immortal = remove_immortal
end
#---
if state.vanish
@hidden = false
end
#---
end
#--------------------------------------------------------------------------
# alias remove states auto
#--------------------------------------------------------------------------
alias remove_states_auto_csp remove_states_auto unless $@
def remove_states_auto
clear_action_results
for state in states
unless @hidden
run_while_effect(state) if state.while_effect > 0
end
end
for i in @state_turns.keys.clone
if @state_turns[i] == 0
unless @hidden
run_leave_effect($data_states[i]) if $data_states[i].leave_effect > 0
end
end
end
remove_states_auto_csp
end
#--------------------------------------------------------------------------
# alias slip damage effect
#--------------------------------------------------------------------------
alias slip_damage_effect_csp slip_damage_effect unless $@
def slip_damage_effect
for state in states
unless @hidden or dead?
degen_regen(state) if state.dr_hp? or state.dr_mp?
end
end
slip_damage_effect_csp
for state in states
run_close_effect(state) if state.close_effect > 0
end
end
#--------------------------------------------------------------------------
# alias execute damage
#--------------------------------------------------------------------------
alias execute_damage_csp execute_damage unless $@
def execute_damage(user, anti_react = false)
if @hidden
@hp_damage = 0
@mp_damage = 0
end
@undead = false
react_states = []
hp_rate_states = []
hp_dmg_states = []
hp_con_states = []
mp_rate_states = []
mp_dmg_states = []
mp_con_states = []
for state in states # push into categories to reduce unnecessary checks
react_states.push(state) if state.react_effect > 0
hp_rate_states.push(state) if state.hp_pain_rate > 0
hp_rate_states.push(state) if state.hp_heal_rate > 0
hp_dmg_states.push(state) if state.super_armour
hp_dmg_states.push(state) if state.invincible_hp
hp_con_states.push(state) if state.hpdmg_mpdmg > 0
hp_con_states.push(state) if state.undead_hp > 0
mp_rate_states.push(state) if state.mp_pain_rate > 0
mp_rate_states.push(state) if state.mp_heal_rate > 0
mp_dmg_states.push(state) if state.super_barrier
mp_dmg_states.push(state) if state.invincible_mp
mp_con_states.push(state) if state.mpdmg_hpdmg > 0
mp_con_states.push(state) if state.undead_mp > 0
end
for state in react_states # first go for react effects
unless @hidden
run_react_effect(state) if state.react_effect > 0 and not anti_react
end
end
for state in hp_rate_states # go for HP rate adjustment
hp_rate_effect(1, state) if state.hp_pain_rate > 0
hp_rate_effect(2, state) if state.hp_heal_rate > 0
end
for state in hp_dmg_states # go for HP effects
super_armour_effect if state.super_armour
@hp_damage = 0 if state.invincible_hp and @hp_damage > 0
end
for state in hp_con_states # go for HP<->MP effects
run_hpdmg_mpdmg(state.hpdmg_mpdmg) if @hp_damage > 0
undead_effect_hp(state.undead_hp) if state.undead_hp > 0
end
for state in mp_rate_states # go for MP rate adjustment
mp_rate_effect(1, state) if state.mp_pain_rate > 0
mp_rate_effect(2, state) if state.mp_heal_rate > 0
end
for state in mp_dmg_states # go for MP effects
super_barrier_effect if state.super_barrier
@mp_damage = 0 if state.invincible_mp and @mp_damage > 0
end
for state in mp_con_states # go for MP<->HP effects
run_mpdmg_hpdmg(state.mpdmg_hpdmg) if @mp_damage > 0
undead_effect_mp(state.undead_hp) if state.undead_mp > 0
end
@absorbed = true if user.absorb_hp and @hp_damage > 0
@absorbed = true if user.absorb_mp and @mp_damage > 0
@absorbed = false if @undead
#--------------
execute_damage_csp(user)
#--------------
self.hp = 0 if @hp_damage > 0 and self.death_hpdmg
self.hp = 0 if @mp_damage > 0 and self.death_mpdmg
self.hp = 0 if @hp_damage < 0 and self.death_hpheal
self.hp = 0 if @mp_damage < 0 and self.death_mpheal
end
#--------------------------------------------------------------------------
# HP/MP Rate Effect
#--------------------------------------------------------------------------
def hp_rate_effect(rate_case, state)
if rate_case == 1
rate = state.hp_pain_rate
if @hp_damage > 0
@hp_damage *= (rate + ((rate - 100) * state_stack(id)))
@hp_damage /= 100
end
else
rate = state.hp_heal_rate
if @hp_damage < 0
@hp_damage *= (rate + ((rate - 100) * state_stack(id)))
@hp_damage /= 100
end
end
end
def mp_rate_effect(rate_case, state)
if rate_case == 1
rate = state.mp_pain_rate
if @mp_damage > 0
@mp_damage *= (rate + ((rate - 100) * state_stack(id)))
@mp_damage /= 100
end
else
rate = state.mp_heal_rate
if @mp_damage < 0
@mp_damage *= (rate + ((rate - 100) * state_stack(id)))
@mp_damage /= 100
end
end
end
#--------------------------------------------------------------------------
# Undead HP/MP effects
#--------------------------------------------------------------------------
def undead_effect_hp(rate)
if @hp_damage < 0
@hp_damage *= -1
@hp_damage *= rate
@hp_damage /= 100
end
@undead = true
end
def undead_effect_mp(rate)
if @mp_damage < 0
@mp_damage *= -1
@mp_damage *= rate
@mp_damage /= 100
end
@undead = true
end
#--------------------------------------------------------------------------
# HP Damage to MP Damage
#--------------------------------------------------------------------------
def run_hpdmg_mpdmg(percent)
hpdmg = @hp_damage * (100 - percent) / 100
mpdmg = @mp_damage + @hp_damage - hpdmg
if mpdmg > self.mp
extra = mpdmg - self.mp
mpdmg = self.mp
hpdmg += extra
end
@hp_damage = hpdmg
@mp_damage = mpdmg
end
#--------------------------------------------------------------------------
# MP Damage to HP Damage
#--------------------------------------------------------------------------
def run_mpdmg_hpdmg(percent)
mpdmg = @mp_damage * (100 - percent) / 100
hpdmg = @hp_damage + @mp_damage - mpdmg
if hpdmg > (self.hp + 1)
extra = hpdmg - self.hp - 1
hpdmg = self.hp - 1
mpdmg += extra
end
@hp_damage = hpdmg
@mp_damage = mpdmg
end
#--------------------------------------------------------------------------
# Super Armour Effect
#--------------------------------------------------------------------------
def super_armour_effect
if @hp_damage > 0
@hp_damage *= YE::BATTLE::SUPER_ARMOUR_PER
@hp_damage /= 100
@hp_damage -= YE::BATTLE::SUPER_ARMOUR_SUB
min_dmg = YE::BATTLE::SUPER_ARMOUR_MIN
@hp_damage = min_dmg if @hp_damage < min_dmg
@hp_damage = 1
end
end
#--------------------------------------------------------------------------
# Super Barrier Effect
#--------------------------------------------------------------------------
def super_barrier_effect
if @mp_damage > 0
@mp_damage *= YE::BATTLE::SUPER_BARRIER_PER
@mp_damage /= 100
@mp_damage -= YE::BATTLE::SUPER_BARRIER_SUB
min_dmg = YE::BATTLE::SUPER_BARRIER_MIN
@mp_damage = min_dmg if @mp_damage < min_dmg
@mp_damage = 1
end
end
#--------------------------------------------------------------------------
# HP/MP Degen/Regen
#--------------------------------------------------------------------------
def degen_regen(state)
id = state.id
if state.dr_hp? and not @hidden
dr_hp = 0
if state.hp_degen_per > 0
dr_hp += self.maxhp * (state.hp_degen_per * (state_stack(id) + 1)) / 100
end
if state.hp_regen_per > 0
dr_hp -= self.maxhp * (state.hp_regen_per * (state_stack(id) + 1)) / 100
end
if state.hp_degen_set > 0
dr_hp += state.hp_degen_set * (state_stack(id) + 1)
end
if state.hp_regen_set > 0
dr_hp -= state.hp_regen_set * (state_stack(id) + 1)
end
dr_hp = self.hp - 1 if dr_hp > self.hp
self.hp -= dr_hp
end
if state.dr_mp? and not @hidden
dr_mp = 0
if state.mp_degen_per > 0
dr_mp += self.maxmp * (state.mp_degen_per * (state_stack(id) + 1)) / 100
end
if state.mp_regen_per > 0
dr_mp -= self.maxmp * (state.mp_regen_per * (state_stack(id) + 1)) / 100
end
if state.mp_degen_set > 0
dr_mp += state.mp_degen_set * (state_stack(id) + 1)
end
if state.mp_regen_set > 0
dr_mp -= state.mp_regen_set * (state_stack(id) + 1)
end
self.mp -= dr_mp
end
end
#--------------------------------------------------------------------------
# hp_damage=, mp_damage=, set_absorb_true
#--------------------------------------------------------------------------
def hp_damage=(value)
@hp_damage = value
end
def mp_damage=(value)
@mp_damage = value
end
def set_absorb_true
@absorbed = true
end
#--------------------------------------------------------------------------
# status_damage
#--------------------------------------------------------------------------
def status_damage(hp_dmg, mp_dmg, target, attacker, anti_react = true,
absorb = false)
target.hp_damage = hp_dmg
target.mp_damage = mp_dmg
target.set_absorb_true if absorb
target.execute_damage(attacker, anti_react)
$scene.display_damage(target)
$scene.display_added_states(target)
end
#--------------------------------------------------------------------------
# msgwait
#--------------------------------------------------------------------------
def msgwait(value = 0)
if value > 0
$scene.wait(value)
elsif $imported["CustomSkillEffects"]
$scene.wait(YE::BATTLE::MSGWAIT)
else
$scene.wait(30)
end
end
#--------------------------------------------------------------------------
# state_turns
#--------------------------------------------------------------------------
def set_state_turns(state_id, new_turns)
new_turns = 1 if new turns <= 0
@state_turns[state_id] = new_turns
end
def state_turns?(state_id)
return @state_turns[state_id]
end
end
#===============================================================================
# Scene_Battle
#===============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# alias start
#--------------------------------------------------------------------------
alias start_csp start unless $@
def start
start_csp
$message__window = @message_window
end
#--------------------------------------------------------------------------
# return active battler
#--------------------------------------------------------------------------
def active_battler
return @active_battler
end
#--------------------------------------------------------------------------
# alias start main
#--------------------------------------------------------------------------
alias start_main_csp start_main unless $@
def start_main
start_main_csp
for member in $game_party.existing_members
for state in member.states
member.run_begin_effect(state) if state.begin_effect > 0
end
end
for member in $game_troop.members
for state in member.states
member.run_begin_effect(state) if state.begin_effect > 0
end
end
end
#--------------------------------------------------------------------------
# alias display_damage
#--------------------------------------------------------------------------
alias display_damage_csp display_damage unless $@
def display_damage(target, obj = nil)
display_damage_csp(target, obj)
for state in target.states
target.run_shock_effect(state) if state.shock_effect > 0
end
end
end #Scene_Battle
#===============================================================================
#
# END OF FILE
#
#===============================================================================
YERD - 커스텀 스킬 이펙트
YERD - 커먼이벤트 샵