Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #===============================================================================
- #
- # Yanfly Engine Zealous - Custom Status Properties
- # Last Date Updated: 2010.02.07
- # Level: Normal, Hard, Lunatic
- #
- # Status effects are a very overlooked aspect in many RPG's. That's because
- # most of the time, they aren't worth using or have completely cheesy effects
- # that nobody wants. This script will allow for more effects in addition to
- # playing animations on battlers when inflicted with a status effect.
- #
- # This script has been remade from the YERD counterpart to have all of the near
- # useless effects removed. Math calculations are now done properly to fit the
- # order of operations, state stacking will return no errors, lunatic mode has
- # been revamped, and states can now play animations on the battlers.
- #
- #===============================================================================
- # Updates
- # -----------------------------------------------------------------------------
- # o 2010.02.07 - Added "immortality" trait.
- # o 2010.01.17 - Critical tag bugfix.
- # o 2010.01.16 - Added compatibility with Aggro and AI.
- # o 2010.01.08 - Job System: Passives Compatibility.
- # o 2010.01.04 - Core Fixes and Upgrades Compatibility.
- # o 2010.01.01 - Job System: Skill Levels Compatibility.
- # o 2009.12.30 - Animation clear bugfix.
- # o 2009.12.20 - Fixed strange bug where stacks don't update HP/MP when done
- # through the skill menu.
- # o 2009.12.19 - Animation loop bug fixed.
- # o 2009.12.17 - Started Script and Finished.
- #===============================================================================
- # Instructions
- # -----------------------------------------------------------------------------
- # To install this script, open up your script editor and copy/paste this script
- # to an open slot below ▼ Materials but above ▼ Main. Remember to save.
- #
- # -----------------------------------------------------------------------------
- # Status Tags - Insert the following tags into a State's notebox.
- # -----------------------------------------------------------------------------
- # <animation n>
- # This will cause the state to play animation n on the battler. One animation
- # can play at a time only so the highest priority state with an animation will
- # take effect. Settings can be adjusted below.
- #
- # <max stack n>
- # This allows your state to stack n times. By default, this value is 1. When a
- # state is applied over again, the stack amount increases. If the stack amount
- # increases, the effects of that state will also be increased depending on the
- # effect and the power of the effect. Tags listed below will make mention of
- # which effects are stackable and which aren't.
- #
- # <stat +n> <stat -n> <stat n%>
- # Replace stat with maxhp, maxmp, atk, def, spi, agi, hit, eva, cri, or odds
- # to increase, decrease, or set the base stat to a percentage. This version
- # will allow you to exceed to the 200% minimum if you use n%. If you plan on
- # using state stacking, it is recommended to use this tag instead of the innate
- # rate system for more accurate calculations. Stackable.
- #
- # <hp degen n> <hp degen n%> or <mp degen n> <mp degen n%>
- # <hp regen n> <hp regen n%> or <mp regen n> <mp regen n%>
- # This causes HP or MP to regenerate or degenerate at the end of each turn. If
- # the tag is used without a %, the amount is set. Otherwise, the amount will be
- # relative to the battler's MaxHP or MP. Stackable.
- #
- # <trait: phrase>
- # This tag allows you to add special traits to the inflicted battlers. The
- # phrase used will cause a different effect. Nonstackable.
- # super guard - Guarding reduces damage by 4x instead of 2x.
- # pharmacology - Items used will have double effect.
- # fast attack - Early turn initiative.
- # dual attack - Normal attacks hit twice.
- # prevent critical - Criticals cannot occur on battler.
- # half mp cost - MP skills cost only half.
- # double exp gain - Inflicted actor gains double exp.
- # auto hp recover - Inflicted actor gains HP each turn and step.
- # anti hp degen - HP degen cannot occur on battler.
- # anti hp regen - HP regen cannot occur on battler.
- # anti mp degen - MP degen cannot occur on battler.
- # anti mp regen - MP regen cannot occur on battler.
- # immortal - Battler cannot die if HP reaches 0.
- #
- #===============================================================================
- # Compatibility
- # -----------------------------------------------------------------------------
- # - Works With: YEZ Battle Engine Zealous
- # -----------------------------------------------------------------------------
- # Note: This script may not work with former Yanfly Engine ReDux scripts.
- # Use Yanfly Engine Zealous scripts to work with this if available.
- #===============================================================================
- $imported = {} if $imported == nil
- $imported["CustomStatusPropertiesZeal"] = true
- module YEZ
- module STATE
- # This decides whether or not your state animations will play sound when
- # they're on. Note that this will play sounds for all state animations
- # present on the screen. You may also turn off full screen animation flash
- # off here. Highly recommended to turn off both.
- ANIMATION_SOUND = false
- ANIMATION_FLASH = false
- # The following determines various aspects for actors. You can decide on
- # whether or not actors will have animations playing on them, what zoom
- # rate will appear for the actors, and what not.
- ANI_ACTOR_SHOW = true
- ANI_ACTOR_ZOOM = 25
- # The following adjusts the rules regarding remained states. A remained
- # state is a state that's already been applied to the battler but is being
- # reapplied. By default, nothing happens to the remained state, but you
- # can make a few changes.
- # 0 - No changes.
- # 1 - Reset turns to the state's starting turn capacity.
- # 2 - Adds extra turns to the state's already existing turns.
- REMAINED_RULES = 1
- # If the following is set to true, then states will automatically update
- # HP and MP to higher amounts if changed. The amounts adjusted will be
- # equal to the HP/MP amount gained/lost.
- UPDATE_ADD = true # Update HP/MP when adding states.
- UPDATE_REM = true # Update HP/MP when removing states.
- # The following will cause remained states to go down in turns after the
- # player takes a certain amount of steps.
- STEP_UPDATE_STATES = true # Enables/Disables state turn update.
- STEPS_PER_ST_TURNS = 3 # Steps for each turn to reduce.
- end # STATE
- end # YEZ
- #===============================================================================
- # Custom Status Properties - Lunatic Mode - Custom Effects
- # ----------------------------------------------------------------------------
- # 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.
- #
- # Lunatic mode for status effects is now remade to share a common effects pool.
- # Here is a list of the different custom effects you can add to your states.
- #
- # <apply effect: phrase> - When adding the state.
- # <erase effect: phrase> - When removing the state.
- # <leave effect: phrase> - When states timer runs out.
- # <react effect: phrase> - Before taking damage.
- # <shock effect: phrase> - After taking damage.
- # <begin effect: phrase> - At the start of each turn.
- # <while effect: phrase> - During battler's turn.
- # <close effect: phrase> - At the end of each turn.
- #
- # Like the YEZ Lunatic Modes, you now enter phrases instead of numbers. Not
- # only that, entering multiple phrases will prompt them to trigger in that
- # order at the proper time for the custom effect to take place.
- #
- # state_origin(effect_state)
- # This new method will return the state's original caster. If no such caster
- # exists, it will be the battler itself. This allows more possibilities for
- # even more special effects.
- #
- #===============================================================================
- class Game_Battler
- #--------------------------------------------------------------------------
- # new method: custom_status_effects
- #--------------------------------------------------------------------------
- def custom_status_effects(effect_state, type = nil)
- return if effect_state == nil
- case type
- when "APPLY"; effects = effect_state.apply_effect
- when "ERASE"; effects = effect_state.erase_effect
- when "LEAVE"; effects = effect_state.leave_effect
- when "REACT"; effects = effect_state.react_effect
- when "SHOCK"; effects = effect_state.shock_effect
- when "BEGIN"; effects = effect_state.begin_effect
- when "WHILE"; effects = effect_state.while_effect
- when "CLOSE"; effects = effect_state.close_effect
- else; return
- end
- return unless effects != []
- for effect in effects
- case effect
- #----------------------------------------------------------------------
- # Start editting here.
- #----------------------------------------------------------------------
- when "DESEOLLUVIA"
- next unless state_origin(effect_state).state?(30)
- self.hp += self.maxhp * 0.67
- when "FERVOR"
- self.add_state(12)
- when "PROTECCION"
- next unless self.hp <= self.maxhp / 2
- self.add_state(14)
- when "PROTECCION2"
- next unless self.hp > self.maxhp / 2
- self.remove_state(14)
- when "INFAMIA"
- $game_troop.members.add_state(10)
- #----------------------------------------------------------------------
- # Stop editting past this point.
- #----------------------------------------------------------------------
- end
- end # for effect in effects
- end # custom_status_effects
- 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 YEZ
- module REGEXP
- module STATE
- CUSTOM_APPLY = /<(?:APPLY_EFFECT|apply effect):[ ](.*)>/i
- CUSTOM_ERASE = /<(?:ERASE_EFFECT|erase effect):[ ](.*)>/i
- CUSTOM_LEAVE = /<(?:LEAVE_EFFECT|leave effect):[ ](.*)>/i
- CUSTOM_REACT = /<(?:REACT_EFFECT|react effect):[ ](.*)>/i
- CUSTOM_SHOCK = /<(?:SHOCK_EFFECT|shock effect):[ ](.*)>/i
- CUSTOM_BEGIN = /<(?:BEGIN_EFFECT|begin effect):[ ](.*)>/i
- CUSTOM_WHILE = /<(?:WHILE_EFFECT|while effect):[ ](.*)>/i
- CUSTOM_CLOSE = /<(?:CLOSE_EFFECT|close effect):[ ](.*)>/i
- STATEANI = /<(?:STATE_ANIMATION|state ani|animation|ani)[ ]*(\d+)>/i
- STAT_SET = /<\s*(MAXHP|MAXMP|HP|MP|ATK|DEF|SPI|AGI|HIT|EVA|CRI|ODDS)?\s*([\+\-]\d+)>/i
- STAT_PER = /<\s*(MAXHP|MAXMP|HP|MP|ATK|DEF|SPI|AGI|HIT|EVA|CRI|ODDS)?\s*(\d+)([%%])>/i
- MAXSTACK = /<(?:MAX_STACK|max stack)[ ]*(\d+)>/i
- TRAITS = /<(?:TRAITS|trait):[ ](.*)>/i
- SLIP_SET = /<\s*(HP|MP)?\s*[ ]\s*(DEGEN|REGEN)?\s*(\d+)>/i
- SLIP_PER = /<\s*(HP|MP)?\s*[ ]\s*(DEGEN|REGEN)?\s*(\d+)([%%])>/i
- end # STATE
- end # REGEXP
- end # YEZ
- #===============================================================================
- # RPG::State
- #===============================================================================
- class RPG::State
- #--------------------------------------------------------------------------
- # common cache: yez_cache_state_csp
- #--------------------------------------------------------------------------
- def yez_cache_state_csp
- @max_stack = 1; @traits = []; @state_animation = 0
- @stat_set ={ :hp => 0, :mp => 0, :atk => 0, :def => 0, :spi => 0,
- :agi => 0, :hit => 0, :eva => 0, :cri => 0, :odds => 0}
- @stat_per ={ :hp => 100, :mp => 100, :atk => 100, :def => 100, :spi => 100,
- :agi => 100, :hit => 100, :eva => 100, :cri => 100, :odds => 100}
- @slip_set ={ :hpdegen => 0, :hpregen => 0, :mpdegen => 0, :mpregen => 0}
- @slip_per ={ :hpdegen => 0, :hpregen => 0, :mpdegen => 0, :mpregen => 0}
- @apply_effect = []; @erase_effect = []; @leave_effect = [];
- @react_effect = []; @shock_effect = []; @begin_effect = [];
- @while_effect = []; @close_effect = [];
- self.note.split(/[\r\n]+/).each { |line|
- case line
- #---
- when YEZ::REGEXP::STATE::CUSTOM_APPLY; @apply_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_ERASE; @erase_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_LEAVE; @leave_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_REACT; @react_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_SHOCK; @shock_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_BEGIN; @begin_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_WHILE; @while_effect.push($1.to_s)
- when YEZ::REGEXP::STATE::CUSTOM_CLOSE; @close_effect.push($1.to_s)
- #---
- when YEZ::REGEXP::STATE::STATEANI
- @state_animation = $1.to_i
- when YEZ::REGEXP::STATE::MAXSTACK
- @max_stack = [$1.to_i, 1].max
- when YEZ::REGEXP::STATE::TRAITS
- @traits.push($1.upcase)
- #---
- when YEZ::REGEXP::STATE::STAT_SET
- case $1.upcase
- when "HP","MAXHP"; @stat_set[:hp] = $2.to_i
- when "MP","MAXMP"; @stat_set[:mp] = $2.to_i
- when "ATK"; @stat_set[:atk] = $2.to_i
- when "DEF"; @stat_set[:def] = $2.to_i
- when "SPI"; @stat_set[:spi] = $2.to_i
- when "AGI"; @stat_set[:agi] = $2.to_i
- when "HIT"; @stat_set[:hit] = $2.to_i
- when "EVA"; @stat_set[:eva] = $2.to_i
- when "CRI"; @stat_set[:cri] = $2.to_i
- when "ODDS"; @stat_set[:odds] = $2.to_i
- end
- #---
- when YEZ::REGEXP::STATE::STAT_PER
- case $1.upcase
- when "HP","MAXHP"; @stat_per[:hp] = $2.to_i
- when "MP","MAXMP"; @stat_per[:mp] = $2.to_i
- when "ATK"; @stat_per[:atk] = $2.to_i
- when "DEF"; @stat_per[:def] = $2.to_i
- when "SPI"; @stat_per[:spi] = $2.to_i
- when "AGI"; @stat_per[:agi] = $2.to_i
- when "HIT"; @stat_per[:hit] = $2.to_i
- when "EVA"; @stat_per[:eva] = $2.to_i
- when "CRI"; @stat_per[:cri] = $2.to_i
- when "ODDS"; @stat_per[:odds] = $2.to_i
- end
- #---
- when YEZ::REGEXP::STATE::SLIP_SET
- case $1.upcase
- when "HP"
- case $2.upcase
- when "DEGEN"; @slip_set[:hpdegen] = $3.to_i
- when "REGEN"; @slip_set[:hpregen] = $3.to_i
- end
- @traits.push("HPSLIP")
- when "MP"
- case $2.upcase
- when "DEGEN"; @slip_set[:mpdegen] = $3.to_i
- when "REGEN"; @slip_set[:mpregen] = $3.to_i
- end
- @traits.push("MPSLIP")
- end
- #---
- when YEZ::REGEXP::STATE::SLIP_PER
- case $1.upcase
- when "HP"
- case $2.upcase
- when "DEGEN"; @slip_per[:hpdegen] = $3.to_i
- when "REGEN"; @slip_per[:hpregen] = $3.to_i
- end
- @traits.push("HPSLIP")
- when "MP"
- case $2.upcase
- when "DEGEN"; @slip_per[:mpdegen] = $3.to_i
- when "REGEN"; @slip_per[:mpregen] = $3.to_i
- end
- @traits.push("MPSLIP")
- end
- #---
- end
- } # end self.note.split
- end # yez_cache_state_csp
- #--------------------------------------------------------------------------
- # new method: apply_effect
- #--------------------------------------------------------------------------
- def apply_effect
- yez_cache_state_csp if @apply_effect == nil
- return @apply_effect
- end
- #--------------------------------------------------------------------------
- # new method: erase_effect
- #--------------------------------------------------------------------------
- def erase_effect
- yez_cache_state_csp if @erase_effect == nil
- return @erase_effect
- end
- #--------------------------------------------------------------------------
- # new method: leave_effect
- #--------------------------------------------------------------------------
- def leave_effect
- yez_cache_state_csp if @leave_effect == nil
- return @leave_effect
- end
- #--------------------------------------------------------------------------
- # new method: react_effect
- #--------------------------------------------------------------------------
- def react_effect
- yez_cache_state_csp if @react_effect == nil
- return @react_effect
- end
- #--------------------------------------------------------------------------
- # new method: shock_effect
- #--------------------------------------------------------------------------
- def shock_effect
- yez_cache_state_csp if @shock_effect == nil
- return @shock_effect
- end
- #--------------------------------------------------------------------------
- # new method: begin_effect
- #--------------------------------------------------------------------------
- def begin_effect
- yez_cache_state_csp if @begin_effect == nil
- return @begin_effect
- end
- #--------------------------------------------------------------------------
- # new method: while_effect
- #--------------------------------------------------------------------------
- def while_effect
- yez_cache_state_csp if @while_effect == nil
- return @while_effect
- end
- #--------------------------------------------------------------------------
- # new method: close_effect
- #--------------------------------------------------------------------------
- def close_effect
- yez_cache_state_csp if @close_effect == nil
- return @close_effect
- end
- #--------------------------------------------------------------------------
- # new method: state_animation
- #--------------------------------------------------------------------------
- def state_animation
- yez_cache_state_csp if @state_animation == nil
- return @state_animation
- end
- #--------------------------------------------------------------------------
- # new method: max_stack
- #--------------------------------------------------------------------------
- def max_stack
- yez_cache_state_csp if @max_stack == nil
- return @max_stack
- end
- #--------------------------------------------------------------------------
- # new method: traits
- #--------------------------------------------------------------------------
- def traits
- yez_cache_state_csp if @traits == nil
- return @traits
- end
- #--------------------------------------------------------------------------
- # new method: stat_set
- #--------------------------------------------------------------------------
- def stat_set
- yez_cache_state_csp if @stat_set == nil
- return @stat_set
- end
- #--------------------------------------------------------------------------
- # new method: stat_per
- #--------------------------------------------------------------------------
- def stat_per
- yez_cache_state_csp if @stat_per == nil
- return @stat_per
- end
- #--------------------------------------------------------------------------
- # new method: slip_set
- #--------------------------------------------------------------------------
- def slip_set
- yez_cache_state_csp if @slip_set == nil
- return @slip_set
- end
- #--------------------------------------------------------------------------
- # new method: slip_per
- #--------------------------------------------------------------------------
- def slip_per
- yez_cache_state_csp if @slip_per == nil
- return @slip_per
- end
- end # RPG::State
- #===============================================================================
- # Game_Battler
- #===============================================================================
- class Game_Battler
- #--------------------------------------------------------------------------
- # public instance variables
- #--------------------------------------------------------------------------
- attr_accessor :state_stack
- attr_accessor :state_animation
- #--------------------------------------------------------------------------
- # alias method: clear_extra_values
- #--------------------------------------------------------------------------
- alias clear_extra_values_csp clear_extra_values unless $@
- def clear_extra_values
- clear_extra_values_csp
- @stack_stack = {}
- @state_origin = {}
- @origin_side = {}
- end
- #--------------------------------------------------------------------------
- # alias method: clear_sprite_effects
- #--------------------------------------------------------------------------
- alias clear_sprite_effects_csp clear_sprite_effects unless $@
- def clear_sprite_effects
- clear_sprite_effects_csp
- @state_animation = 0
- end
- #--------------------------------------------------------------------------
- # new method: reload_state_animation
- #--------------------------------------------------------------------------
- def reload_state_animation
- @state_animation = 0
- return if actor? and !YEZ::STATE::ANI_ACTOR_SHOW
- for state in states
- next unless state.state_animation > 0
- @state_animation = state.state_animation
- break
- end
- end
- #--------------------------------------------------------------------------
- # overwrite method: state?
- #--------------------------------------------------------------------------
- def state?(state_id)
- return states.include?($data_states[state_id])
- end
- #--------------------------------------------------------------------------
- # overwrite method: apply_state_changes
- #--------------------------------------------------------------------------
- def apply_state_changes(obj)
- plus = obj.plus_state_set
- minus = obj.minus_state_set
- if obj.is_a?(RPG::Skill) or obj.is_a?(RPG::Item)
- plus += $scene.active_battler.plus_state_set if obj.physical_attack
- end
- for i in plus
- next if state_resist?(i)
- next if dead?
- next if i == 1 and @immortal
- if state?(i)
- remained_rules(i, obj)
- @remained_states.push(i) unless @remained_states.include?(i)
- next
- end
- if rand(100) < state_probability(i)
- add_state(i)
- @added_states.push(i) unless @added_states.include?(i)
- end
- end
- for i in minus
- next unless state?(i)
- remove_state(i)
- @removed_states.push(i) unless @removed_states.include?(i)
- end
- for i in @added_states & @removed_states
- @added_states.delete(i)
- @removed_states.delete(i)
- end
- for i in @added_states
- apply_state_turns(obj, i) if $imported["JobSystemSkillLevels"]
- end
- end
- #--------------------------------------------------------------------------
- # new method: remained_rules
- #--------------------------------------------------------------------------
- def remained_rules(state_id, obj = nil)
- state = $data_states[state_id]
- return if state == nil
- hpdif = self.maxhp
- mpdif = self.maxmp
- increase_stack(state_id)
- case YEZ::STATE::REMAINED_RULES
- when 0 # No changes
- return
- when 1 # Reset Turns
- @state_turns[state_id] = state.hold_turn
- when 2 # Add Turns
- @state_turns[state_id] = state.hold_turn if !@state_turns.include?(state_id)
- @state_turns[state_id] += state.hold_turn
- end
- if !dead? and YEZ::STATE::UPDATE_ADD
- self.hp += maxhp - hpdif
- self.mp += maxmp - mpdif
- end
- end
- #--------------------------------------------------------------------------
- # alias method: skill_test
- #--------------------------------------------------------------------------
- alias skill_test_csp skill_test unless $@
- def skill_test(user, skill)
- for state_id in skill.plus_state_set
- state = $data_states[state_id]
- next if state == nil
- return true if state.max_stack > self.stack(state)
- end
- return skill_test_csp(user, skill)
- end
- #--------------------------------------------------------------------------
- # alias method: add_state
- #--------------------------------------------------------------------------
- alias add_state_csp add_state unless $@
- def add_state(state_id)
- create_state_origin(state_id)
- custom_status_effects($data_states[state_id], "APPLY")
- hpdif = maxhp
- mpdif = maxmp
- increase_stack(state_id)
- add_state_csp(state_id)
- if !dead? and YEZ::STATE::UPDATE_ADD
- self.hp += maxhp - hpdif
- self.mp += maxmp - mpdif
- end
- reload_state_animation
- end
- #--------------------------------------------------------------------------
- # alias method: remove_state
- #--------------------------------------------------------------------------
- alias remove_state_csp remove_state unless $@
- def remove_state(state_id)
- custom_status_effects($data_states[state_id], "ERASE")
- hpdif = maxhp
- mpdif = maxmp
- reset_stack(state_id)
- remove_state_csp(state_id)
- if !dead? and YEZ::STATE::UPDATE_REM
- self.hp += maxhp - hpdif
- self.mp += maxmp - mpdif
- end
- @removed_states.push(1) if dead? and !@removed_states.include?(1)
- clear_state_origin(state_id)
- reload_state_animation
- end
- #--------------------------------------------------------------------------
- # alias method: remove_states_auto
- #--------------------------------------------------------------------------
- alias remove_states_auto_csp remove_states_auto unless $@
- def remove_states_auto
- clear_action_results
- unless @hidden
- for state in states; custom_status_effects(state, "WHILE"); end
- for i in @state_turns.keys.clone
- custom_status_effects($data_states[id], "LEAVE") if @state_turns[i] == 0
- end
- end
- remove_states_auto_csp
- end
- #--------------------------------------------------------------------------
- # alias method: execute_damage
- #--------------------------------------------------------------------------
- alias execute_damage_csp execute_damage unless $@
- def execute_damage(user)
- for state in states; custom_status_effects(state, "REACT"); end
- execute_damage_csp(user)
- for state in states; custom_status_effects(state, "SHOCK"); end
- end
- #--------------------------------------------------------------------------
- # new method: create_state_origin
- #--------------------------------------------------------------------------
- def create_state_origin(state_id)
- @state_origin = {} if @state_origin == nil
- @origin_side = {} if @origin_side == nil
- return unless $scene.is_a?(Scene_Battle)
- return if $scene.active_battler == nil
- if $scene.active_battler.actor?
- @state_origin[state_id] = $scene.active_battler.id
- @origin_side[state_id] = 0
- else
- @state_origin[state_id] = $scene.active_battler.index
- @origin_side[state_id] = 1
- end
- end
- #--------------------------------------------------------------------------
- # new method: clear_state_origin
- #--------------------------------------------------------------------------
- def clear_state_origin(state_id)
- @state_origin = {} if @state_origin == nil
- @origin_side = {} if @origin_side == nil
- @state_origin.delete(state_id)
- @origin_side.delete(state_id)
- end
- #--------------------------------------------------------------------------
- # new method: state_origin
- #--------------------------------------------------------------------------
- def state_origin(state_id)
- state_id = state_id.id if state_id.is_a?(RPG::State)
- @state_origin = {} if @state_origin == nil
- @origin_side = {} if @origin_side == nil
- if @origin_side.include?(state_id)
- if @origin_side[state_id] == 0
- return $game_actors[@state_origin[state_id]]
- else
- return $game_troop.members[@state_origin[state_id]]
- end
- else
- return self
- end
- end
- #--------------------------------------------------------------------------
- # new method: reset_state_origins
- #--------------------------------------------------------------------------
- def reset_state_origins
- @state_origin = {}
- @origin_side = {}
- end
- #--------------------------------------------------------------------------
- # new method: stack
- #--------------------------------------------------------------------------
- def stack(state)
- @state_stack = {} if @state_stack == nil
- state = $data_states[state] if state.is_a?(Integer)
- return 0 if state == nil
- return 0 if !state?(state.id)
- n = 1
- m = @state_stack.include?(state.id) ? @state_stack[state.id] : 0
- return [n, m].max
- end
- #--------------------------------------------------------------------------
- # new method: increase_stack
- #--------------------------------------------------------------------------
- def increase_stack(state_id, stack_up = 1)
- state = $data_states[state_id]
- return if state == nil
- @state_stack = {} if @state_stack == nil
- @state_stack[state_id] = 0 if @state_stack[state_id] == nil
- return if @state_stack[state_id] > state.max_stack
- @state_stack[state_id] += stack_up
- @state_stack[state_id] = [@state_stack[state_id], state.max_stack].min
- @added_states.push(state_id) unless state_id == 1
- end
- #--------------------------------------------------------------------------
- # new method: reset_stack
- #--------------------------------------------------------------------------
- def reset_stack(state_id)
- @state_stack = {} if @state_stack == nil
- @state_stack.delete(state_id)
- end
- #--------------------------------------------------------------------------
- # alias method: maxhp
- #--------------------------------------------------------------------------
- alias maxhp_csp maxhp unless $@
- def maxhp
- n = maxhp_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:hp] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:hp]; end
- end
- n = [[Integer(n), 1].max, maxhp_limit].min
- @hp = [@hp, n].min
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: maxmp
- #--------------------------------------------------------------------------
- alias maxmp_csp maxmp unless $@
- def maxmp
- n = maxmp_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:mp] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:mp]; end
- end
- limit = (defined?(maxmp_limit) ? maxmp_limit : 9999)
- n = [[Integer(n), 1].max, limit].min
- @mp = [@mp, n].min
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: atk
- #--------------------------------------------------------------------------
- alias atk_csp atk unless $@
- def atk
- n = atk_csp
- for state in states
- percent = 100
- for i in 2..stack(state); percent += state.atk_rate - 100; end
- n = n * percent / 100.0
- end
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:atk] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:atk]; end
- end
- limit = (defined?(parameter_limit) ? parameter_limit : 999)
- n = [[Integer(n), 1].max, limit].min
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: def
- #--------------------------------------------------------------------------
- alias def_csp def unless $@
- def def
- n = def_csp
- for state in states
- percent = 100
- for i in 2..stack(state); percent += state.def_rate - 100; end
- n = n * percent / 100.0
- end
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:def] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:def]; end
- end
- limit = (defined?(parameter_limit) ? parameter_limit : 999)
- n = [[Integer(n), 1].max, limit].min
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: spi
- #--------------------------------------------------------------------------
- alias spi_csp spi unless $@
- def spi
- n = spi_csp
- for state in states
- percent = 100
- for i in 2..stack(state); percent += state.spi_rate - 100; end
- n = n * percent / 100.0
- end
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:spi] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:spi]; end
- end
- limit = (defined?(parameter_limit) ? parameter_limit : 999)
- n = [[Integer(n), 1].max, limit].min
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: agi
- #--------------------------------------------------------------------------
- alias agi_csp agi unless $@
- def agi
- n = agi_csp
- for state in states
- percent = 100
- for i in 2..stack(state); percent += state.agi_rate - 100; end
- n = n * percent / 100.0
- end
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:agi] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:agi]; end
- end
- limit = (defined?(parameter_limit) ? parameter_limit : 999)
- n = [[Integer(n), 1].max, limit].min
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # new method: trait?
- #--------------------------------------------------------------------------
- def trait?(phrase)
- for state in states; return true if state.traits.include?(phrase); end
- return false
- end
- #--------------------------------------------------------------------------
- # alias method: super_guard
- #--------------------------------------------------------------------------
- alias super_guard_battler_csp super_guard unless $@
- def super_guard
- traits = ["SUPER_GUARD", "SUPER GUARD", "SUPERGUARD"]
- for state in states; return true if (state.traits & traits) != []; end
- return super_guard_battler_csp
- end
- #--------------------------------------------------------------------------
- # alias method: fast_attack
- #--------------------------------------------------------------------------
- alias fast_attack_battler_csp fast_attack unless $@
- def fast_attack
- traits = ["FAST_ATTACK", "FAST ATTACK", "FASTATTACK"]
- for state in states; return true if (state.traits & traits) != []; end
- return fast_attack_battler_csp
- end
- #--------------------------------------------------------------------------
- # alias method: dual_attack
- #--------------------------------------------------------------------------
- alias dual_attack_battler_csp dual_attack unless $@
- def dual_attack
- traits = ["DUAL_ATTACK", "DUAL ATTACK", "DUALATTACK"]
- for state in states; return true if (state.traits & traits) != []; end
- return dual_attack_battler_csp
- end
- #--------------------------------------------------------------------------
- # alias method: prevent_critical
- #--------------------------------------------------------------------------
- alias prevent_critical_battler_csp prevent_critical unless $@
- def prevent_critical
- traits = ["PREVENT_CRITICAL", "PREVENT CRITICAL", "PREVENTCRITICAL",
- "PREVENT_CRIT", "PREVENT CRIT"]
- for state in states; return true if (state.traits & traits) != []; end
- return prevent_critical_battler_csp
- end
- #--------------------------------------------------------------------------
- # alias method: half_mp_cost
- #--------------------------------------------------------------------------
- alias half_mp_cost_battler_csp half_mp_cost unless $@
- def half_mp_cost
- traits = ["HALF_MP_COST", "HALF MP COST", "HALFMPCOST", "HALF_MP",
- "HALF MP", "HALFMP"]
- for state in states; return true if (state.traits & traits) != []; end
- return half_mp_cost_battler_csp
- end
- #--------------------------------------------------------------------------
- # new method: immortal
- #--------------------------------------------------------------------------
- def immortal
- traits = ["IMMORTAL", "CANNOT DIE", "IMMORTALITY"]
- for state in states; return true if (state.traits & traits) != []; end
- return @immortal
- end
- #--------------------------------------------------------------------------
- # alias method: slip_damage_effect
- #--------------------------------------------------------------------------
- alias slip_damage_effect_csp slip_damage_effect unless $@
- def slip_damage_effect
- slip_damage_effect_csp
- hpslip if trait?("HPSLIP")
- mpslip if trait?("MPSLIP")
- for state in states; custom_status_effects(state, "CLOSE"); end
- end
- #--------------------------------------------------------------------------
- # new method: hpslip
- #--------------------------------------------------------------------------
- def hpslip
- return if dead?
- n = 0
- if !trait?("ANTI HP DEGEN") or !trait?("ANTI_HP_DEGEN")
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.slip_per[:hpdegen]; end
- n += maxhp * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.slip_set[:hpdegen]; end
- end
- end
- if !trait?("ANTI HP REGEN") or !trait?("ANTI_HP_REGEN")
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.slip_per[:hpregen]; end
- n -= maxhp * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n -= state.slip_set[:hpregen]; end
- end
- end
- self.hp -= [Integer(n), self.hp - 1].min
- end
- #--------------------------------------------------------------------------
- # new method: mpslip
- #--------------------------------------------------------------------------
- def mpslip
- return if dead?
- n = 0
- if !trait?("ANTI MP DEGEN") or !trait?("ANTI_MP_DEGEN")
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.slip_per[:mpdegen]; end
- n += maxmp * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.slip_set[:mpdegen]; end
- end
- end
- if !trait?("ANTI MP REGEN") or !trait?("ANTI_MP_REGEN")
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.slip_per[:mpregen]; end
- n -= maxmp * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n -= state.slip_set[:mpregen]; end
- end
- end
- self.mp -= Integer(n)
- end
- end # Game_Battler
- #===============================================================================
- # Game_Actor
- #===============================================================================
- class Game_Actor
- #--------------------------------------------------------------------------
- # alias method: hit
- #--------------------------------------------------------------------------
- alias hit_actor_csp hit unless $@
- def hit
- n = hit_actor_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:hit] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:hit]; end
- end
- n = [Integer(n), 0].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: eva
- #--------------------------------------------------------------------------
- alias eva_actor_csp eva unless $@
- def eva
- n = eva_actor_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:eva] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:eva]; end
- end
- n = [Integer(n), 0].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: cri
- #--------------------------------------------------------------------------
- alias cri_actor_csp cri unless $@
- def cri
- n = cri_actor_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:cri] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:cri]; end
- end
- n = [Integer(n), 0].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: odds
- #--------------------------------------------------------------------------
- alias odds_actor_csp odds unless $@
- def odds
- n = odds_actor_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:odds] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:odds]; end
- end
- n = [Integer(n), 1].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: super_guard
- #--------------------------------------------------------------------------
- alias super_guard_actor_csp super_guard unless $@
- def super_guard
- return true if trait?("SUPER_GUARD")
- return true if trait?("SUPER GUARD")
- return true if trait?("SUPERGUARD")
- return super_guard_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: pharmacology
- #--------------------------------------------------------------------------
- alias pharmacology_actor_csp pharmacology unless $@
- def pharmacology
- return true if trait?("PHARMACOLOGY")
- return true if trait?("ITEM_BOOST")
- return true if trait?("ITEM BOOST")
- return pharmacology_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: fast_attack
- #--------------------------------------------------------------------------
- alias fast_attack_actor_csp fast_attack unless $@
- def fast_attack
- return true if trait?("FAST_ATTACK")
- return true if trait?("FAST ATTACK")
- return true if trait?("FASTATTACK")
- return fast_attack_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: dual_attack
- #--------------------------------------------------------------------------
- alias dual_attack_actor_csp dual_attack unless $@
- def dual_attack
- return true if trait?("DUAL_ATTACK")
- return true if trait?("DUAL ATTACK")
- return true if trait?("DUALATTACK")
- return dual_attack_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: prevent_critical
- #--------------------------------------------------------------------------
- alias prevent_critical_actor_csp prevent_critical unless $@
- def prevent_critical
- return true if trait?("PREVENT_CRITICAL")
- return true if trait?("PREVENT CRITICAL")
- return true if trait?("PREVENTCRITICAL")
- return true if trait?("PREVENT_CRIT")
- return true if trait?("PREVENT CRIT")
- return prevent_critical_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: half_mp_cost
- #--------------------------------------------------------------------------
- alias half_mp_cost_actor_csp half_mp_cost unless $@
- def half_mp_cost
- return true if trait?("HALF_MP_COST")
- return true if trait?("HALF MP COST")
- return true if trait?("HALFMPCOST")
- return true if trait?("HALF_MP")
- return true if trait?("HALF MP")
- return true if trait?("HALFMP")
- return half_mp_cost_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: double_exp_gain
- #--------------------------------------------------------------------------
- alias double_exp_gain_actor_csp double_exp_gain unless $@
- def double_exp_gain
- return true if trait?("DOUBLE_EXP_GAIN")
- return true if trait?("DOUBLE EXP GAIN")
- return true if trait?("DOUBLE EXP")
- return double_exp_gain_actor_csp
- end
- #--------------------------------------------------------------------------
- # alias method: auto_hp_recover
- #--------------------------------------------------------------------------
- alias auto_hp_recover_actor_csp auto_hp_recover unless $@
- def auto_hp_recover
- return true if trait?("AUTO_HP_RECOVER")
- return true if trait?("AUTO HP RECOVER")
- return auto_hp_recover_actor_csp
- end
- end # Game_Actor
- #===============================================================================
- # Game_Enemy
- #===============================================================================
- class Game_Enemy < Game_Battler
- #--------------------------------------------------------------------------
- # alias method: hit
- #--------------------------------------------------------------------------
- alias hit_enemy_csp hit unless $@
- def hit
- n = hit_enemy_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:hit] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:hit]; end
- end
- n = [Integer(n), 0].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: eva
- #--------------------------------------------------------------------------
- alias eva_enemy_csp eva unless $@
- def eva
- n = eva_enemy_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:eva] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:eva]; end
- end
- n = [Integer(n), 0].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: cri
- #--------------------------------------------------------------------------
- alias cri_enemy_csp cri unless $@
- def cri
- n = cri_enemy_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:cri] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:cri]; end
- end
- n = [Integer(n), 0].max
- return Integer(n)
- end
- #--------------------------------------------------------------------------
- # alias method: odds
- #--------------------------------------------------------------------------
- alias odds_enemy_csp odds unless $@
- def odds
- n = odds_enemy_csp
- for state in states
- percent = 100
- for i in 1..stack(state); percent += state.stat_per[:odds] - 100; end
- n = n * percent / 100.0
- end
- for state in states;
- for i in 1..stack(state); n += state.stat_set[:odds]; end
- end
- n = [Integer(n), 1].max
- return Integer(n)
- end
- end # Game_Enemy
- #==============================================================================
- # Game_Party
- #==============================================================================
- class Game_Party < Game_Unit
- #--------------------------------------------------------------------------
- # alias method: on_player_walk
- #--------------------------------------------------------------------------
- alias on_player_walk_csp on_player_walk unless $@
- def on_player_walk
- on_player_walk_csp
- return unless YEZ::STATE::STEP_UPDATE_STATES
- return unless @steps % YEZ::STATE::STEPS_PER_ST_TURNS == 0
- for actor in members
- actor.remove_states_auto
- end
- end
- end # Game_Party
- #===============================================================================
- # Sprite_Battler
- #===============================================================================
- class Sprite_Battler < Sprite_Base
- #--------------------------------------------------------------------------
- # class variable
- #--------------------------------------------------------------------------
- @@state_animations = []
- RATE = $imported["CoreFixesUpgrades"] ? YEZ::FIXES::ANIMATION_RATE : 4
- #--------------------------------------------------------------------------
- # alias method: initialize
- #--------------------------------------------------------------------------
- alias initialize_sprite_battler_csp initialize unless $@
- def initialize(viewport, battler = nil)
- initialize_sprite_battler_csp(viewport, battler)
- @state_animation_duration = 0
- end
- #--------------------------------------------------------------------------
- # alias method: dispose
- #--------------------------------------------------------------------------
- alias dispose_sprite_battler_csp dispose unless $@
- def dispose
- dispose_sprite_battler_csp
- dispose_state_animation
- end
- #--------------------------------------------------------------------------
- # alias method: update
- #--------------------------------------------------------------------------
- alias update_sprite_battler_csp update unless $@
- def update
- update_sprite_battler_csp
- if @state_animation != nil
- @state_animation_duration -= 1
- if @state_animation_duration % RATE == 0
- update_state_animation
- end
- end
- @@state_animations.clear
- end
- #--------------------------------------------------------------------------
- # alias method: setup_new_effect
- #--------------------------------------------------------------------------
- alias setup_new_effect_sprite_battler_csp setup_new_effect unless $@
- def setup_new_effect
- setup_new_effect_sprite_battler_csp
- if @battler.state_animation != nil
- if @battler.state_animation == 0
- dispose_state_animation
- else
- start_state_animation($data_animations[@battler.state_animation])
- end
- end
- end
- #--------------------------------------------------------------------------
- # new method: start_state_animation
- #--------------------------------------------------------------------------
- def start_state_animation(animation)
- return if @state_animation != nil and @state_animation.id == animation.id
- dispose_state_animation
- @state_animation = animation
- return if @state_animation == nil
- @state_animation_mirror = false
- @state_animation_duration = @state_animation.frame_max * RATE + 1
- load_state_animation_bitmap
- @state_animation_sprites = []
- if @state_animation.position != 3 or !@@state_animations.include?(animation)
- if @use_sprite
- for i in 0..15
- sprite = ::Sprite.new(viewport)
- sprite.visible = false
- @state_animation_sprites.push(sprite)
- end
- unless @@state_animations.include?(animation)
- @@state_animations.push(animation)
- end
- end
- end
- if @state_animation.position == 3
- if viewport == nil
- @state_animation_ox = 544 / 2
- @state_animation_oy = 416 / 2
- else
- @state_animation_ox = viewport.rect.width / 2
- @state_animation_oy = viewport.rect.height / 2
- end
- else
- @state_animation_ox = x - ox + width / 2
- @state_animation_oy = y - oy + height / 2
- if @state_animation.position == 0
- @state_animation_oy -= height / 2
- elsif @state_animation.position == 2
- @state_animation_oy += height / 2
- end
- end
- end
- #--------------------------------------------------------------------------
- # new method: load_state_animation_bitmap
- #--------------------------------------------------------------------------
- def load_state_animation_bitmap
- animation1_name = @state_animation.animation1_name
- animation1_hue = @state_animation.animation1_hue
- animation2_name = @state_animation.animation2_name
- animation2_hue = @state_animation.animation2_hue
- @state_animation_bitmap1 = Cache.animation(animation1_name, animation1_hue)
- @state_animation_bitmap2 = Cache.animation(animation2_name, animation2_hue)
- if @@_reference_count.include?(@state_animation_bitmap1)
- @@_reference_count[@state_animation_bitmap1] += 1
- else
- @@_reference_count[@state_animation_bitmap1] = 1
- end
- if @@_reference_count.include?(@state_animation_bitmap2)
- @@_reference_count[@state_animation_bitmap2] += 1
- else
- @@_reference_count[@state_animation_bitmap2] = 1
- end
- Graphics.frame_reset
- end
- #--------------------------------------------------------------------------
- # new method: dispose_state_animation
- #--------------------------------------------------------------------------
- def dispose_state_animation
- if @state_animation_bitmap1 != nil
- @@_reference_count[@state_animation_bitmap1] -= 1
- if @@_reference_count[@state_animation_bitmap1] == 0
- @state_animation_bitmap1.dispose
- end
- end
- if @state_animation_bitmap2 != nil
- @@_reference_count[@state_animation_bitmap2] -= 1
- if @@_reference_count[@state_animation_bitmap2] == 0
- @state_animation_bitmap2.dispose
- end
- end
- if @state_animation_sprites != nil
- for sprite in @state_animation_sprites
- sprite.dispose
- end
- @state_animation_sprites = nil
- @state_animation = nil
- end
- @state_animation_bitmap1 = nil
- @state_animation_bitmap2 = nil
- end
- #--------------------------------------------------------------------------
- # new method: update_state_animation
- #--------------------------------------------------------------------------
- def update_state_animation
- if @state_animation_duration > 0
- frame_index = @state_animation.frame_max -
- (@state_animation_duration + RATE - 1) / RATE
- state_animation_set_sprites(@state_animation.frames[frame_index])
- for timing in @state_animation.timings
- if timing.frame == frame_index
- state_animation_process_timing(timing)
- end
- end
- else
- @state_animation_duration = @state_animation.frame_max * RATE + 1
- end
- if @state_animation.position == 3
- if viewport == nil
- @state_animation_ox = 544 / 2
- @state_animation_oy = 416 / 2
- else
- @state_animation_ox = viewport.rect.width / 2
- @state_animation_oy = viewport.rect.height / 2
- end
- else
- @state_animation_ox = x - ox + width / 2
- @state_animation_oy = y - oy + height / 2
- if @state_animation.position == 0
- @state_animation_oy -= height / 2
- elsif @state_animation.position == 2
- @state_animation_oy += height / 2
- end
- end
- end
- #--------------------------------------------------------------------------
- # new method: state_animation_set_sprites
- #--------------------------------------------------------------------------
- def state_animation_set_sprites(frame)
- cell_data = frame.cell_data
- for i in 0..15
- sprite = @state_animation_sprites[i]
- next if sprite == nil
- pattern = cell_data[i, 0]
- if pattern == nil or pattern == -1
- sprite.visible = false
- next
- end
- if pattern < 100
- sprite.bitmap = @state_animation_bitmap1
- else
- sprite.bitmap = @state_animation_bitmap2
- end
- sprite.visible = true
- sprite.src_rect.set(pattern % 5 * 192,
- pattern % 100 / 5 * 192, 192, 192)
- if @state_animation_mirror
- sprite.x = @state_animation_ox - cell_data[i, 1]
- sprite.y = @state_animation_oy + cell_data[i, 2]
- sprite.angle = (360 - cell_data[i, 4])
- sprite.mirror = (cell_data[i, 5] == 0)
- else
- sprite.x = @state_animation_ox + cell_data[i, 1]
- sprite.y = @state_animation_oy + cell_data[i, 2]
- sprite.angle = cell_data[i, 4]
- sprite.mirror = (cell_data[i, 5] == 1)
- end
- sprite.z = self.z + 300 + i
- sprite.ox = 96
- sprite.oy = 96
- sprite.zoom_x = cell_data[i, 3] / 100.0
- sprite.zoom_y = cell_data[i, 3] / 100.0
- if @battler.actor?
- sprite.zoom_x *= YEZ::STATE::ANI_ACTOR_ZOOM
- sprite.zoom_x /= 100
- sprite.zoom_y *= YEZ::STATE::ANI_ACTOR_ZOOM
- sprite.zoom_y /= 100
- end
- sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
- sprite.blend_type = cell_data[i, 7]
- end
- end
- #--------------------------------------------------------------------------
- # new method: state_animation_process_timing
- #--------------------------------------------------------------------------
- def state_animation_process_timing(timing)
- timing.se.play if YEZ::STATE::ANIMATION_SOUND
- case timing.flash_scope
- when 1
- self.flash(timing.flash_color, timing.flash_duration * RATE)
- when 2
- return unless YEZ::STATE::ANIMATION_FLASH
- if viewport != nil
- viewport.flash(timing.flash_color, timing.flash_duration * RATE)
- end
- when 3
- self.flash(nil, timing.flash_duration * RATE)
- end
- end
- end # Sprite_Battler
- #===============================================================================
- # Scene_Battle
- #===============================================================================
- class Scene_Battle < Scene_Base
- #--------------------------------------------------------------------------
- # public instance variables
- #--------------------------------------------------------------------------
- attr_accessor :active_battler
- #--------------------------------------------------------------------------
- # alias method: start
- #--------------------------------------------------------------------------
- alias start_battle_csp start unless $@
- def start
- start_battle_csp
- for member in $game_party.members + $game_troop.members
- member.reload_state_animation
- end
- end
- #--------------------------------------------------------------------------
- # alias method: start_main
- #--------------------------------------------------------------------------
- alias start_main_csp start_main unless $@
- def start_main
- start_main_csp
- for member in ($game_party.members + $game_troop.members)
- for state in member.states
- member.custom_status_effects(state, "BEGIN")
- end
- end
- end
- #--------------------------------------------------------------------------
- # alias method: battle_end
- #--------------------------------------------------------------------------
- alias battle_end_csp battle_end unless $@
- def battle_end(result)
- battle_end_csp(result)
- for member in $game_party.members; member.reset_state_origins; end
- end
- end # Scene_Battle
- #===============================================================================
- #
- # END OF FILE
- #
- #===============================================================================
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement