Скрипт на доработку

#============================================================================== # ** Victor Engine - Damage Popup #------------------------------------------------------------------------------ # Author : Victor Sant # # Version History: # v 1.00 - 2011.12.19 > First relase # v 1.01 - 2011.12.21 > Added bold and Italic options for text # v 1.02 - 2011.12.30 > Faster Regular Expressions # v 1.03 - 2012.01.18 > Added compatibility with Skip Battle Log # v 1.04 - 2012.01.28 > Fixed zero damage displayed on status effect actions # > Fixed drain value not displayed # v 1.05 - 2012.01.30 > Fixed debuff value not displayed # v 1.06 - 2012.07.17 > Compatibility with Basic Module 1.24 # > Individual duration for each pop up type # v 1.07 - 2012.07.18 > Compatibility with Retaliation Damage # v 1.08 - 2012.08.02 > Compatibility with Custom Slip Effect # v 1.09 - 2012.08.18 > Compatibility with Custom Hit Formula #------------------------------------------------------------------------------ # This script adds an popup system to damage diplay. Allowing to view # the damage and states change with visible digits that pop from target. # It's possible an extensive edition of this display. #------------------------------------------------------------------------------ # Compatibility # Requires the script 'Victor Engine - Basic Module' v1.27 or higher # If used with 'Victor Engine - Custom Slip Effect' place this bellow it. # If used with 'Victor Engine - Custom Hit Formula' place this bellow it. # # * Overwrite methods # class Window_BattleLog < Window_Selectable # def display_critical(target, item) # # * Alias methods # class Game_ActionResult # def clear_damage_values # # class Game_Battler < Game_BattlerBase # def item_element_rate # def regenerate_hp # def regenerate_mp # def regenerate_tp # def item_apply(user, item) # def execute_damage(user) # def remove_states_auto(timing) # # class Sprite_Battler # def initialize(viewport, battler = nil) # def update_effect # def dispose # # class Scene_Battle < Scene_Base # def invoke_counter_attack(target, item) # def invoke_magic_reflection(target, item) # def apply_substitute # #------------------------------------------------------------------------------ # Instructions: # To instal the script, open you script editor and paste this script on # a new section bellow the Materials section. This script must also # be bellow the script 'Victor Engine - Basic' # #------------------------------------------------------------------------------ # States note tags # Tags to be used on the States note box in the database # # <no display add> # <no display rmv> # This allows to hide the state popup display. # # <damage behavior: x> # This tag change the behavior of the damage display of the state, # x must be a text with the name of the new behavior, the new behavior # must be set previously on the settings module # # <add color: r, g, b> # This will change the color of the text when inflicting a state. # r : red (0-255) # g : green (0-255) # b : blue (0-255) # # <remove color: r, g, b> # This will change the color of the text when losing a state. # r : red (0-255) # g : green (0-255) # b : blue (0-255) # #------------------------------------------------------------------------------ # Skills and Items note tags # Tags to be used on the Skills and Items note box in the database # # <damage behavior: x> # This will change the behavior of the damage display of the action, # x must be a text with the name of the new behavior, the new behavior # must be set previously on the settings module # #------------------------------------------------------------------------------ # Additional instructions: # # Custom display behaviors must be set on the following constant of the # settings module, otherwise it will return erros: # - VE_DAMAGE_TEXTS (if VE_DAMAGE_DISPLAY = :text) # - VE_DAMAGE_IMGS (if VE_DAMAGE_DISPLAY = :image) # - VE_DAMAGE_MOVE # #============================================================================== #============================================================================== # ** Victor Engine #------------------------------------------------------------------------------ # Setting module for the Victor Engine #============================================================================== module Victor_Engine #-------------------------------------------------------------------------- # * Deteremine the damage display # It's posssible to choose between texts drawn by the RPG Maker # (draw_text) or specific images # :text : display by text, the settings are done on Damage_Text. # :image : display by image, the settings are done on Damage_Images. # It's needed to create a new folder on 'Graphics' folder named 'Digits' #-------------------------------------------------------------------------- VE_DAMAGE_DISPLAY = :text #-------------------------------------------------------------------------- # * Set popup custom text constants #-------------------------------------------------------------------------- VE_HP_DAMAGE = "%s" # HP damage text (use %s to show the value) VE_MP_DAMAGE = "%s" # MP damage text (use %s to show the value) VE_TP_DAMAGE = "%s" # TP damage text (use %s to show the value) VE_HP_RECOVER = "%s" # HP recovery text (use %s to show the value) VE_MP_RECOVER = "%s" # MP recovery text (use %s to show the value) VE_TP_RECOVER = "%s" # TP recovery text (use %s to show the value) VE_MISS_TEXT = "Промах" # Miss text VE_EVADE_TEXT = "Мимо" # Evade text VE_CRT_TEXT = "Крит!" # Critical text (only if CTR_POP = true) VE_WEAK_TEXT = "Weak" # Weakness text (only if RESIST_POP = true) VE_RESIST_TEXT = "Сопрот." # Resistance text (only if RESIST_POP = true) VE_IMUNE_TEXT = "Imune" # Imune text (only if RESIST_POP = true) VE_ABSORB_TEXT = "Absorb" # Absorb text (only if RESIST_POP = true) VE_COUNTER_TEXT = "Counter" # Counter attack text VE_REFLECT_TEXT = "Reflect" # Reflect magic text VE_COVER_TEXT = "Covered" # Cover text VE_STATE_ADD = "+%s" # Add state text (use %s to show state name) VE_STATE_REMOVE = "-%s" # Remove state text (use %s to show state name) VE_BUFF_ADD = "%s +1" # Buff text (use %s to show status name) VE_DEBUFF_ADD = "%s -1" # DeBuff text (use %s to show status name) VE_BUFF_RMV = "%s " # Clear buff text (use %s to show status name) #-------------------------------------------------------------------------- # * Set popup boleans constants (true/false) # The critical text (VE_CRT_POP) and resistance texts (VE_RESIST_POP) # don't have the multi pop effect (VE_MULTI_POP), so it's advised to # not use these options activated toghter. #-------------------------------------------------------------------------- VE_DIGIT_ROLL = false # Digit roll during the start of display VE_FAST_ROLL = false # Fast digit roll (may cause lag) VE_DIGIT_EACH = false # Digits shown in sequence VE_MULTI_POP = false # Digits with delay VE_COUNTER_POP = true # Show counter popup message VE_REFLECT_POP = true # Show reflect popup message VE_COVER_POP = true # Show covered popup message VE_CRT_FLASH = true # Flash effect for critical damage VE_CRT_POP = true # Show critical text with critical damage VE_RESIST_POP = true # Show resist text with normal damage VE_HEIGHT_ADJ = true # Adjust position based on target graphic height VE_AUTO_ADJ = true # Adjust height if there is various damage diplays #-------------------------------------------------------------------------- # * Set popup numeric values constants #-------------------------------------------------------------------------- VE_DIGIT_SPACE = 0 # Space between the digits on the display #-------------------------------------------------------------------------- # * Set values for text damage display (VE_DAMAGE_DISPLAY = :text) #-------------------------------------------------------------------------- VE_DAMAGE_TEXTS = { # Type [ Red, Green, Blue, Size, Wait, Bold, Italic, Font], default: [ 255, 255, 255, 32, 50, true, false, Font.default_name], hp_damage: [ 255, 255, 255, 32, 50, true, false, Font.default_name], mp_damage: [ 128, 96, 255, 32, 50, true, false, Font.default_name], tp_damage: [ 96, 192, 96, 32, 50, true, false, Font.default_name], hp_recover: [ 160, 255, 128, 32, 50, true, false, Font.default_name], mp_recover: [ 255, 128, 255, 32, 50, true, false, Font.default_name], tp_recover: [ 128, 255, 224, 32, 50, true, false, Font.default_name], miss_text: [ 160, 160, 160, 32, 50, true, false, Font.default_name], eva_text: [ 160, 160, 160, 32, 50, true, false, Font.default_name], crt_damage: [ 255, 96, 0, 36, 50, true, false, Font.default_name], crt_text: [ 255, 128, 96, 22, 50, true, false, Font.default_name], weakness: [ 255, 128, 128, 22, 50, true, false, Font.default_name], resist: [ 128, 255, 255, 22, 50, true, false, Font.default_name], imune: [ 160, 160, 160, 22, 50, true, false, Font.default_name], absorb: [ 128, 255, 128, 22, 50, true, false, Font.default_name], counter: [ 255, 192, 128, 22, 50, true, false, Font.default_name], reflect: [ 128, 192, 255, 22, 50, true, false, Font.default_name], covered: [ 192, 255, 128, 22, 50, true, false, Font.default_name], state_add: [ 255, 255, 128, 22, 50, true, false, Font.default_name], state_rmv: [ 128, 255, 255, 22, 50, true, false, Font.default_name], buff_add: [ 255, 255, 128, 22, 50, true, false, Font.default_name], debuff_add: [ 255, 128, 128, 22, 50, true, false, Font.default_name], buff_rmv: [ 128, 255, 255, 22, 50, true, false, Font.default_name], } # Don't remove #-------------------------------------------------------------------------- # * Set values for text damage display (VE_DAMAGE_DISPLAY = :image) # For critical text (:crt_text), resists (:weakness, :resist, imune, # :absorb) and state change (:state_add, :state_rmv, :buff_add, ) # and , use a single image for the whole text, for the others (including # miss and evade text), use a singe image for each digit. #-------------------------------------------------------------------------- VE_DAMAGE_IMGS = { #type: [Wait, "sufix"], default: [ 50, ""], # Default text hp_damage: [ 50, ""], # HP damage sp_damage: [ 50, "_mp"], # MP damage tp_damage: [ 50, "_tp"], # TP damage hp_recover: [ 50, "_heal"], # HP recover sp_recover: [ 50, "_mpheal"], # MP recover tp_recover: [ 50, "_tpheal"], # TP recover miss_text: [ 50, "_miss"], # Miss text eva_text: [ 50, "_evade"], # Evade text crt_damage: [ 50, "_crtdmg"], # Critical damage crt_text: [ 50, "_crttxt"], # Critical text weakness: [ 50, "_weak"], # Weakness text resist: [ 50, "_resist"], # Resist text imune: [ 50, "_imune"], # Imune text absorb: [ 50, "_absorb"], # Absorb text counter: [ 50, "_cntr"], # Counter text reflect: [ 50, "_rflct"], # Reflection text covered: [ 50, "_cover"], # Cover text state_add: [ 50, "_addst"], # State add text state_rmv: [ 50, "_rmvst"], # State remove text buff_add: [ 50, "_addbf"], # Buff text debuff_add: [ 50, "_adddbf"], # Debuff text buff_rmv: [ 50, "_rmvbf"], # Clear buff text } # Don't remove #-------------------------------------------------------------------------- # * Set damage display behavior # The damage display have 3 phases: Start, Middle and End. # It's possible to set diffent behaviors for each of these phases # The behaviors are set on the VE_POP_BEHAVIOR constant bellow #-------------------------------------------------------------------------- VE_DAMAGE_MOVE = { #type: [ Start, Middle, Fim], default: [ :wait, :wait, :wait], # Default text hp_damage: [ :pop1, :pop2, :wait], # HP damage mp_damage: [ :pop1, :pop2, :wait], # MP damage tp_damage: [ :pop1, :pop2, :wait], # TP damage hp_recover: [ :zoom1, :up, :up], # HP recover mp_recover: [ :up_l, :up_r, :up_l], # MP recover tp_recover: [ :up_l, :up_r, :up_l], # TP recover miss_text: [ :wait, :wait, :wait], # Miss text eva_text: [ :wait, :wait, :wait], # Evade text crt_damage: [ :zoom1, :wait, :rise1], # Critical damage crt_text: [ :zoom2, :wait, :rise2], # Critical text weakness: [ :above, :pop2, :wait], # Weakness text resist: [ :above, :pop2, :wait], # Resist text imune: [ :above, :pop2, :wait], # Imune text absorb: [ :zoom2, :up, :up], # Absorb text counter: [ :up, :wait, :wait], # Counter text reflect: [ :up, :wait, :wait], # Reflection text covered: [ :up, :wait, :wait], # Cover text state_add: [ :wait, :wait, :wait], # State add text state_rmv: [ :wait, :wait, :wait], # State remove text buff_add: [ :wait, :wait, :wait], # Buff add text debuff_add: [ :wait, :wait, :wait], # Debuff add text buff_rmv: [ :wait, :wait, :wait], # Clear buff add text } # Don't remove #-------------------------------------------------------------------------- # * Set the damage pop behavior for each phase # ZoomX : vertical zoom # ZoomY : horizontal zoom # StartX : initial coordinate X (valid only for the Start phase) # StartY : initial coordinate Y (valid only for the Start phase) # MoveX : horizontal movment # MoveY : vertical movement # Gravt : gravity effect (makes the damage "jumps") # Random : random horizontal movement #-------------------------------------------------------------------------- VE_POP_BEHAVIOR = { #type: [ZoomX, ZoomY, StartX, StartY, MoveX, MoveY, Gravt, Random], wait: [ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, false], zoom1: [ 2.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0, false], zoom2: [ 2.0, 2.0, 0.0, -8.0, 0.0, 0.0, 0.0, false], rise1: [ 1.0, 3.0, 0.0, 0.0, 0.0, -2.0, 0.0, false], rise2: [ 1.0, 3.0, 0.0, 0.0, 0.0, -5.0, 0.0, false], up: [ 1.0, 1.0, 0.0, 0.0, 0.0, -3.0, 0.0, false], pop1: [ 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 4.0, false], pop2: [ 1.0, 1.0, 0.0, 0.0, 0.0, 0.5, 2.0, false], above: [ 1.0, 1.0, 0.0, -8.0, 0.0, 1.0, 4.0, false], up_r: [ 1.0, 1.0, 0.0, 0.0, 1.0, -1.0, 0.0, false], up_l: [ 1.0, 1.0, 0.0, 0.0, -1.0, -1.0, 0.0, false], } # Don't remove #-------------------------------------------------------------------------- # * required # This method checks for the existance of the basic module and other # VE scripts required for this script to work, don't edit this #-------------------------------------------------------------------------- def self.required(name, req, version, type = nil) if !$imported[:ve_basic_module] msg = "The script '%s' requires the script\n" msg += "'VE - Basic Module' v%s or higher above it to work properly\n" msg += "Go to http://victorscripts.wordpress.com/ to download this script." msgbox(sprintf(msg, self.script_name(name), version)) exit else self.required_script(name, req, version, type) end end #-------------------------------------------------------------------------- # * script_name # Get the script name base on the imported value, don't edit this #-------------------------------------------------------------------------- def self.script_name(name, ext = "VE") name = name.to_s.gsub("_", " ").upcase.split name.collect! {|char| char == ext ? "#{char} -" : char.capitalize } name.join(" ") end end $imported ||= {} $imported[:ve_damage_pop] = 1.09 Victor_Engine.required(:ve_damage_pop, :ve_basic_module, 1.27, :above) #============================================================================== # ** Cache #------------------------------------------------------------------------------ # This module loads each of graphics, creates a Bitmap object, and retains it. # To speed up load times and conserve memory, this module holds the created # Bitmap object in the internal hash, allowing the program to return # preexisting objects when the same bitmap is requested again. #============================================================================== module Cache #-------------------------------------------------------------------------- # * New method: digits #-------------------------------------------------------------------------- def self.digits(filename) load_bitmap("Graphics/Digits/", filename) end end #============================================================================== # ** Game_Action #------------------------------------------------------------------------------ # This class handles battle actions. This class is used within the # Game_Battler class. #============================================================================== class Game_Action #-------------------------------------------------------------------------- # * Alias method: evaluate_item_with_target #-------------------------------------------------------------------------- alias :evaluate_item_with_target_ve_damage_pop :evaluate_item_with_target def evaluate_item_with_target(target) result = evaluate_item_with_target_ve_damage_pop(target) target.result.clear result end end #============================================================================== # ** Game_ActionResult #------------------------------------------------------------------------------ # This class handles the results of actions. This class is used within the # Game_Battler class. #============================================================================== class Game_ActionResult #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :resist attr_accessor :tp_drain #-------------------------------------------------------------------------- # * Alias method: clear_damage_values #-------------------------------------------------------------------------- alias :clear_damage_values_ve_damage_pop :clear_damage_values def clear_damage_values clear_damage_values_ve_damage_pop @resist = nil @tp_drain = 0 end end #============================================================================== # ** Game_Battler #------------------------------------------------------------------------------ # This class deals with battlers. It's used as a superclass of the Game_Actor # and Game_Enemy classes. #============================================================================== class Game_Battler < Game_BattlerBase #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :damaged attr_accessor :counter attr_accessor :reflect attr_accessor :covered attr_accessor :missed attr_accessor :no_dmg #-------------------------------------------------------------------------- # * Alias method: item_element_rate #-------------------------------------------------------------------------- alias :item_element_rate_ve_damage_pop :item_element_rate def item_element_rate(user, item) result = item_element_rate_ve_damage_pop(user, item) @result.resist = :weakness if result > 1.0 @result.resist = :resist if result < 1.0 && result > 0.0 @result.resist = :imune if result == 0.0 @result.resist = :absorb if result < 0.0 result end #-------------------------------------------------------------------------- # * Alias method: item_apply #-------------------------------------------------------------------------- alias :item_apply_ve_damage_pop :item_apply def item_apply(user, item) item_apply_ve_damage_pop(user, item) @damaged = ($game_party.in_battle && @result.hit?) @missed = ($game_party.in_battle && alive? && !@result.hit?) @no_dmg = item.damage.none? end #-------------------------------------------------------------------------- # * Alias method: regenerate_hp #-------------------------------------------------------------------------- alias :regenerate_hp_ve_damage_pop :regenerate_hp def regenerate_hp regenerate_hp_ve_damage_pop @damaged |= $game_party.in_battle && damaged? end #-------------------------------------------------------------------------- # * Alias method: regenerate_mp #-------------------------------------------------------------------------- alias :regenerate_mp_ve_damage_pop :regenerate_mp def regenerate_mp regenerate_mp_ve_damage_pop @damaged |= $game_party.in_battle && damaged? end #-------------------------------------------------------------------------- # * Alias method: regenerate_tp #-------------------------------------------------------------------------- alias :regenerate_tp_ve_damage_pop :regenerate_tp def regenerate_tp regenerate_tp_ve_damage_pop @result.tp_damage = -mtp * trg unless $imported[:ve_custom_slip_effect] @damaged |= $game_party.in_battle && damaged? end #-------------------------------------------------------------------------- # * Alias method: execute_damage #-------------------------------------------------------------------------- alias :execute_damage_tp_ve_damage_pop :execute_damage def execute_damage(user) execute_damage_tp_ve_damage_pop(user) if @result.hp_drain != 0 || @result.mp_drain != 0 user.damaged = true user.result.hp_damage = -@result.hp_drain user.result.mp_damage = -@result.mp_drain end end #-------------------------------------------------------------------------- # * Alias method: remove_states_auto #-------------------------------------------------------------------------- alias :remove_states_auto_ve_damage_pop :remove_states_auto def remove_states_auto(timing) old_states = states.dup remove_states_auto_ve_damage_pop(timing) @damaged |= $game_party.in_battle && old_states != states.dup @no_dmg = @result.hp_damage == 0 || @result.mp_drain == 0 end #-------------------------------------------------------------------------- # * New method: clear_damage_flags #-------------------------------------------------------------------------- def clear_damage_flags @damaged = false @counter = false @reflect = false @covered = false @missed = false @no_dmg = false end end #============================================================================== # ** Sprite_Battler #------------------------------------------------------------------------------ # This sprite is used to display battlers. It observes a instance of the # Game_Battler class and automatically changes sprite conditions. #============================================================================== class Sprite_Battler < Sprite_Base #-------------------------------------------------------------------------- # * Alias method: initialize #-------------------------------------------------------------------------- alias :initialize_ve_damage_pop :initialize def initialize(viewport, battler = nil) initialize_ve_damage_pop(viewport, battler) @damage_sprite = Game_Damage.new(viewport, @battler, self) end #-------------------------------------------------------------------------- # * Alias method: initialize #-------------------------------------------------------------------------- alias :update_effect_ve_damage_pop :update_effect def update_effect update_effect_ve_damage_pop set_damage if @battler.damaged || @battler.missed @damage_sprite.update end #-------------------------------------------------------------------------- # * Alias method: dispose #-------------------------------------------------------------------------- alias :dispose_ve_damage_pop :dispose def dispose dispose_ve_damage_pop @damage_sprite.dispose end #-------------------------------------------------------------------------- # * New method: set_damage #-------------------------------------------------------------------------- def set_damage @damage_sprite.set_damage(@battler) if @battler && @battler.use_sprite? @battler.clear_damage_flags end end #============================================================================== # ** Window_BattleLog #------------------------------------------------------------------------------ # This window shows the battle progress. Do not show the window frame. #============================================================================== class Window_BattleLog < Window_Selectable #-------------------------------------------------------------------------- # * Overwrite method: display_critical #-------------------------------------------------------------------------- def display_critical(target, item) if target.result.critical color = [255, 255, 255, 192] if VE_CRT_FLASH $game_troop.screen.start_flash(Color.new(*color), 10) if VE_CRT_FLASH text = target.actor? ? Vocab::CriticalToActor : Vocab::CriticalToEnemy add_text(text) unless $imported[:ve_skip_log] && !VE_CRITICAL_MESSAGE end end end #============================================================================== # ** Scene_Battle #------------------------------------------------------------------------------ # This class performs battle screen processing. #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # * Alias method: invoke_counter_attack #-------------------------------------------------------------------------- alias :invoke_counter_attack_ve_damage_pop :invoke_counter_attack def invoke_counter_attack(target, item) target.counter = true if VE_COUNTER_POP && counter_pop_up?(target, item) target.damaged = true if VE_COUNTER_POP && counter_pop_up?(target, item) invoke_counter_attack_ve_damage_pop(target, item) end #-------------------------------------------------------------------------- # * Alias method: invoke_magic_reflection #-------------------------------------------------------------------------- alias :invoke_magic_reflection_ve_damage_pop :invoke_magic_reflection def invoke_magic_reflection(target, item) target.reflect = true if VE_REFLECT_POP && reflect_pop_up?(target, item) target.damaged = true if VE_REFLECT_POP && reflect_pop_up?(target, item) invoke_magic_reflection_ve_damage_pop(target, item) end #-------------------------------------------------------------------------- # * Alias method: apply_substitute #-------------------------------------------------------------------------- alias :apply_substitute_ve_damage_pop :apply_substitute def apply_substitute(target, item) new_target = apply_substitute_ve_damage_pop(target, item) target.covered = true if new_target != target && VE_COVER_POP target.damaged = true if new_target != target && VE_COVER_POP new_target end #-------------------------------------------------------------------------- # * New method: counter_pop_up? #-------------------------------------------------------------------------- def counter_pop_up?(target, item) !$imported[:ve_retaliation_damage] || !damage_on_counter?(target, item) end #-------------------------------------------------------------------------- # * New method: reflect_pop_up? #-------------------------------------------------------------------------- def reflect_pop_up?(target, item) !$imported[:ve_retaliation_damage] || !damage_on_reflect?(target, item) end end #============================================================================== # ** Game_Damage #------------------------------------------------------------------------------ # This class handles the damage display. This class is used within the # Sprite_Battler. #============================================================================== class Game_Damage #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize(viewport, battler, sprite) @x = 0 @y = 0 @exw = 0 @viewport = Viewport.new(0, 0, Graphics.width, Graphics.height) @viewport.z = 500 @battler = battler @sprite = sprite @damage_sprites = [] end #-------------------------------------------------------------------------- # * results #-------------------------------------------------------------------------- def result @battler.result end #-------------------------------------------------------------------------- # * hp_damage #-------------------------------------------------------------------------- def hp_damage result.hp_damage.abs end #-------------------------------------------------------------------------- # * mp_damage #-------------------------------------------------------------------------- def mp_damage result.mp_damage.abs end #-------------------------------------------------------------------------- # * tp_damage #-------------------------------------------------------------------------- def tp_damage result.tp_damage.abs end #-------------------------------------------------------------------------- # * set_damage #-------------------------------------------------------------------------- def set_damage(battler) @battler = battler @dmg_text = damage_value.to_s @dmg_type = damage_type create_damage_sprites end #-------------------------------------------------------------------------- # * damage_value #-------------------------------------------------------------------------- def damage_value return VE_COUNTER_TEXT if @battler.counter return VE_REFLECT_TEXT if @battler.reflect return VE_COVER_TEXT if @battler.covered return sprintf(VE_HP_DAMAGE, hp_damage) if result.hp_damage > 0 return sprintf(VE_MP_DAMAGE, mp_damage) if result.mp_damage > 0 return sprintf(VE_TP_DAMAGE, tp_damage) if result.tp_damage > 0 return sprintf(VE_HP_RECOVER, hp_damage) if result.hp_damage < 0 return sprintf(VE_MP_RECOVER, mp_damage) if result.mp_damage < 0 return sprintf(VE_TP_RECOVER, tp_damage) if result.tp_damage < 0 return VE_MISS_TEXT if result.missed return VE_EVADE_TEXT if result.evaded return "" if @battler.no_dmg return 0 end #-------------------------------------------------------------------------- # * damage_type #-------------------------------------------------------------------------- def damage_type return :counter if @battler.counter return :reflect if @battler.reflect return :covered if @battler.covered return custom_type if custom_type return :crt_damage if result.hp_damage > 0 && result.critical return :hp_damage if result.hp_damage > 0 return :mp_damage if result.mp_damage > 0 return :tp_damage if result.tp_damage > 0 return :hp_recover if result.hp_damage < 0 return :mp_recover if result.mp_damage < 0 return :tp_recover if result.tp_damage < 0 return :miss_text if result.missed return :eva_text if result.evaded return :default end #-------------------------------------------------------------------------- # * custom_type #-------------------------------------------------------------------------- def custom_type return nil unless @battler.current_action return nil unless @battler.current_action.item note = @battler.current_action.item.note type = nil type = eval(":#{$1}") if note =~ /<DAMAGE BEHAVIOR: ([^>< ]*)>/i type end #-------------------------------------------------------------------------- # * create_damage_sprites #-------------------------------------------------------------------------- def create_damage_sprites @damage_sprites.compact! set_normal_damage set_critical if result.critical && VE_CRT_POP set_resist if result.resist && VE_RESIST_POP set_states end #-------------------------------------------------------------------------- # * state_change #-------------------------------------------------------------------------- def state_change (result.added_states + result.removed_states + result.added_buffs + result.removed_buffs) end #-------------------------------------------------------------------------- # * state_changed? #-------------------------------------------------------------------------- def state_changed? !state_change.empty? end #-------------------------------------------------------------------------- # * set_normal_damage #-------------------------------------------------------------------------- def set_normal_damage @rnd = 2.0 - (rand(400) / 100.0) @exw = 0 set = [] n = damage_value.numeric? @dmg_text.size.times {|i| set.push(set_sprite(@dmg_text, @dmg_type, i, n)) } set.each {|sprite| sprite.plus = @exw } @damage_sprites.push(set) @exw = @rnd = 0 end #-------------------------------------------------------------------------- # * set_critical #-------------------------------------------------------------------------- def set_critical set = [set_sprite(VE_CRT_TEXT, :crt_text, -1)] set.each {|sprite| sprite.set_position } @damage_sprites.push(set) end #-------------------------------------------------------------------------- # * set_resist #-------------------------------------------------------------------------- def set_resist set = [set_sprite(get_resist, result.resist, -1)] set.each {|sprite| sprite.set_position } @damage_sprites.push(set) end #-------------------------------------------------------------------------- # * set_states #-------------------------------------------------------------------------- def set_states set_state_sprite(result.added_states, :state_add) set_state_sprite(result.removed_states, :state_rmv) set_buff_sprite(result.added_buffs, :buff_add) set_buff_sprite(result.added_debuffs, :debuff_add) set_buff_sprite(result.removed_buffs, :buff_rmv) end #-------------------------------------------------------------------------- # * set_other #-------------------------------------------------------------------------- def set_other set = [set_sprite(VE_COUNTER_TEXT, :counter, -1)] if @battler.counter set = [set_sprite(VE_REFLECT_TEXT, :reflect, -1)] if @battler.reflect set = [set_sprite(VE_COVER_TEXT, :covered, -1)] if @battler.covered set.each {|sprite| sprite.set_position } @damage_sprites.push(set) end #-------------------------------------------------------------------------- # * set_sprite #-------------------------------------------------------------------------- def set_sprite(text, type, index = 0, num = false, state = nil) x = @sprite.x y = @sprite.y - (VE_HEIGHT_ADJ ? @sprite.center_y : 64) size = @damage_sprites.size info = {i: index, text: text, type: type, x: x, y: y, size: size, num: num} sprite = Sprite_Damage.new(@viewport, @battler, @exw, @rnd, state, info) @exw += sprite.space unless index < 0 sprite end #-------------------------------------------------------------------------- # * get_resist #-------------------------------------------------------------------------- def get_resist case result.resist when :weakness then VE_WEAK_TEXT when :resist then VE_RESIST_TEXT when :imune then VE_IMUNE_TEXT when :absorb then VE_ABSORB_TEXT else "" end end #-------------------------------------------------------------------------- # * set_state_sprite #-------------------------------------------------------------------------- def set_state_sprite(list, type) list.each do |id| next if no_state_display(type, id) behavior = state_type(id, type) name = state_text(id, type) set = [set_sprite(name, behavior, -1, false, id)] set.each {|sprite| sprite.set_position } @damage_sprites.push(set) end end #-------------------------------------------------------------------------- # * no_state_display #-------------------------------------------------------------------------- def no_state_display(type, id) note = $data_states[id].note return true if note =~ /<NO DISPLAY ADD>/i return true if type == :state_add && note =~ /<NO DISPLAY ADD>/i return true if type == :state_rmv && note =~ /<NO DISPLAY RMV>/i return false end #-------------------------------------------------------------------------- # * set_buff_sprite #-------------------------------------------------------------------------- def set_buff_sprite(list, type) list.each do |id| set = [set_sprite(buff_text(id, type), type, -1, false, id)] set.each {|sprite| sprite.set_position } @damage_sprites.push(set) end end #-------------------------------------------------------------------------- # * state_text #-------------------------------------------------------------------------- def state_text(id, type) sprintf(get_state_text(type), $data_states[id].name) end #-------------------------------------------------------------------------- # * buff_text #-------------------------------------------------------------------------- def buff_text(id, type) sprintf(get_state_text(type), Vocab::param(id)) end #-------------------------------------------------------------------------- # * get_state_text #-------------------------------------------------------------------------- def get_state_text(type) case type when :state_add then VE_STATE_ADD when :state_rmv then VE_STATE_REMOVE when :buff_add then VE_BUFF_ADD when :debuff_add then VE_DEBUFF_ADD when :buff_rmv then VE_BUFF_RMV end end #-------------------------------------------------------------------------- # * state_type #-------------------------------------------------------------------------- def state_type(id, type) note = $data_states[id].note type = type type = eval(":#{$1}") if note =~ /<DAMAGE[ _]*BEHAVIOR:? +([^>< ]*)>/i type end #-------------------------------------------------------------------------- # * update #-------------------------------------------------------------------------- def update @damage_sprites.each do |set| set.each do |sprite| sprite.update set.delete_if {|sprite| sprite.disposed? } end set.compact! end @damage_sprites.delete_if {|set| set.empty? } end #-------------------------------------------------------------------------- # * dispose #-------------------------------------------------------------------------- def dispose @damage_sprites.each do |set| set.each {|sprite| sprite.dispose unless sprite.disposed? } end @viewport.dispose end end #============================================================================== # ** Sprite_Damage #------------------------------------------------------------------------------ # This sprite is used to display damage. It observes a instance of the # Game_Damage class and automatically changes sprite conditions. #============================================================================== class Sprite_Damage < Sprite_Base #-------------------------------------------------------------------------- # * initialize #-------------------------------------------------------------------------- def initialize(wiewport, battler, exw, rnd, state, info) super(wiewport) @battler = battler @exw = exw @rnd = rnd @state = state ? $data_states[state] : nil start_info(info) start_basic start_misc end #-------------------------------------------------------------------------- # * start_info #-------------------------------------------------------------------------- def start_info(info) @index = info[:i] @text = info[:text] @type = info[:type] @pos_x = info[:x] @pos_y = info[:y] @dmg_size = info[:size] @numeric = info[:num] end #-------------------------------------------------------------------------- # * start_basic #-------------------------------------------------------------------------- def start_basic @wait = VE_DAMAGE_DISPLAY == :text ? get_text[4] : get_sprite[0] @base = VE_DAMAGE_DISPLAY == :text ? get_text[4] : get_sprite[0] @delay = VE_MULTI_POP ? @index * 4 : 1 @digit = VE_DIGIT_ROLL @each = VE_DIGIT_EACH @adjust = VE_AUTO_ADJ end #-------------------------------------------------------------------------- # * start_misc #-------------------------------------------------------------------------- def start_misc @size = text? ? 0.75 : (@text.size / 2.0) - @index @move = VE_DAMAGE_MOVE[@type] @pop = VE_POP_BEHAVIOR @plus = 0 @adj_zx = 0.0 @adj_zy = 0.0 @speed = 0.0 @list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] @dmg_bitmap = create_bitmap(@index) self.opacity = 0 end #-------------------------------------------------------------------------- # * create_bitmap #-------------------------------------------------------------------------- def create_bitmap(i, n = nil) VE_DAMAGE_DISPLAY == :text ? create_text(i, n) : create_sprite(i, n) end #-------------------------------------------------------------------------- # * create_sprite #-------------------------------------------------------------------------- def create_sprite(index, fixed = nil) text = fixed ? fixed.to_s : index < 0 ? @text : @text[index..index] begin digit = Cache.digits(text.to_s + get_sprite[1]) rescue digit = Cache.digits(text.to_s) end bitmap = Bitmap.new(digit.width, digit.height) rect = Rect.new(0, 0, digit.width, digit.height) bitmap.blt(0, 0, digit, rect) bitmap end #-------------------------------------------------------------------------- # * create_text #-------------------------------------------------------------------------- def create_text(index, fixed = nil) text = fixed ? fixed.to_s : index < 0 ? @text : @text[index..index] dummy_bitmap = Bitmap.new(160, font_size + 2) dummy_bitmap.font.size = font_size dummy_bitmap.font.name = font_name dummy_bitmap.font.bold = font_bold dummy_bitmap.font.italic = font_italic dummy_bitmap.sfont = $sfont[0] if $imported[:ve_sfonts] adjust = font_italic ? 4 : 2 size = dummy_bitmap.text_size(text).width + adjust dummy_bitmap.dispose bitmap = damage_bitmap(size) bitmap.draw_text(1, 0, size, font_size, text) bitmap end #-------------------------------------------------------------------------- # * damage_bitmap #-------------------------------------------------------------------------- def damage_bitmap(size) bitmap = Bitmap.new(size, font_size) bitmap.font.size = font_size bitmap.font.name = font_name bitmap.font.bold = font_bold bitmap.font.italic = font_italic bitmap.font.color.set(*get_color) bitmap.sfont = $sfont[0] if $imported[:ve_sfonts] && VE_ALL_SFONT bitmap end #-------------------------------------------------------------------------- # * get_color #-------------------------------------------------------------------------- def get_color add_color = /<ADD COLOR: ((?:\d+,? *){3})>/i rmv_color = /<REMOVE COLOR: ((?:\d+,? *){3})>/i if @state && @type == :state_add && @state.note =~ add_color color = get_state_color($1.dup) elsif @state && @type == :state_rmv && @state.note =~ rmv_color color = get_state_color($1.dup) else color = [get_text[0], get_text[1], get_text[2]] end color end #-------------------------------------------------------------------------- # * get_text #-------------------------------------------------------------------------- def get_text VE_DAMAGE_TEXTS[@type] ? VE_DAMAGE_TEXTS[@type] : VE_DAMAGE_TEXTS[:default] end #-------------------------------------------------------------------------- # * get_sprite #-------------------------------------------------------------------------- def get_sprite VE_DAMAGE_IMGS[@type] ? VE_DAMAGE_IMGS[@type] : VE_DAMAGE_IMGS[:default] end #-------------------------------------------------------------------------- # * font_size #-------------------------------------------------------------------------- def font_size get_text[3] end #-------------------------------------------------------------------------- # * font_bold #-------------------------------------------------------------------------- def font_bold get_text[5] end #-------------------------------------------------------------------------- # * font_italic #-------------------------------------------------------------------------- def font_italic get_text[6] end #-------------------------------------------------------------------------- # * font_name #-------------------------------------------------------------------------- def font_name get_text[7] end #-------------------------------------------------------------------------- # * get_state_color #-------------------------------------------------------------------------- def get_state_color(info) if info =~ /(\d+) *,? *(\d+) *,? *(\d+)/i color = [$1.to_i, $2.to_i, $3.to_i] else color = [255, 255, 255] end color end #-------------------------------------------------------------------------- # * space #-------------------------------------------------------------------------- def space @dmg_bitmap.width + VE_DIGIT_SPACE end #-------------------------------------------------------------------------- # * Definição de posição #-------------------------------------------------------------------------- def set_position update_digit_bitmap @base_x = @dmg_bitmap ? @dmg_bitmap.width / 2 : 0 @base_y = @dmg_bitmap ? @dmg_bitmap.height / 2 : 0 adjust_x = text? ? 0 : @plus / 2 - @base_x adjust_y = (@adjust && @text != "") ? @dmg_size * 16 : 0 move = @pop[@move[0]] self.zoom_x = move[0] self.zoom_y = move[1] self.x = @pos_x + @exw + move[2] - adjust_x - spriteset_viewport.ox self.y = @pos_y + move[3] - adjust_y - spriteset_viewport.oy self.z = 3000 end #-------------------------------------------------------------------------- # * spriteset_viewport #-------------------------------------------------------------------------- def spriteset_viewport SceneManager.scene.spriteset.viewport1 end #-------------------------------------------------------------------------- # * text? #-------------------------------------------------------------------------- def text? @index < 0 end #-------------------------------------------------------------------------- # * plus #-------------------------------------------------------------------------- def plus=(plus) @plus = plus set_position end #-------------------------------------------------------------------------- # * update #-------------------------------------------------------------------------- def update @delay -= 1 return if self.disposed? || @delay > 0 super @wait -= 1 update_digit_bitmap update_speed update_damage_move update_zoom update_move update_opacity end #-------------------------------------------------------------------------- # * update_digit_bitmap #-------------------------------------------------------------------------- def update_digit_bitmap if @each && each_digit self.bitmap = nil elsif @numeric && @digit && !waiting && digit_roll self.bitmap = create_bitmap(@index, random_digit) else self.bitmap = @dmg_bitmap end end #-------------------------------------------------------------------------- # * waiting #-------------------------------------------------------------------------- def waiting (Graphics.frame_count % 3 != 0 && !VE_FAST_ROLL) end #-------------------------------------------------------------------------- # * each_digit #-------------------------------------------------------------------------- def each_digit (@wait - (@index * 5) + (@dmg_size * 5) >= @base) end #-------------------------------------------------------------------------- # * digit_roll #-------------------------------------------------------------------------- def digit_roll (@wait > (@base * 0.5) + (@each ? @index * 5 : 0)) end #-------------------------------------------------------------------------- # * random_digit #-------------------------------------------------------------------------- def random_digit digit = @list.random! @list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] if @list.empty? digit end #-------------------------------------------------------------------------- # * update_damage_move #-------------------------------------------------------------------------- def update_damage_move a = @pop[@move[0]] b = @pop[@move[1]] c = @pop[@move[2]] if @wait > @base * 2.0 / 3.0 set_move_values(a[0], b[0], a[1], b[1], a[4], a[5], a[6], a[7]) elsif @wait < @base / 3.0 set_move_values(b[0], c[0], b[1], c[1], c[4], c[5], c[6], c[7]) else set_move_values(0, 0, 0, 0, b[4], b[5], b[6], b[7]) end end #-------------------------------------------------------------------------- # * Definição dos valores de movimento # args : valores #-------------------------------------------------------------------------- def set_move_values(*args) @adj_x = (args[0] - args[1]) / (@base * 0.33) @adj_y = (args[2] - args[3]) / (@base * 0.33) @zoom_max_x = args[1] @zoom_max_y = args[3] @move_x = args[4] * (args[7] ? @random : 1.0) * (@damage_mirror ? -1 : 1) @move_y = args[5] @gravity = -args[6] end #-------------------------------------------------------------------------- # * update_zoom #-------------------------------------------------------------------------- def update_zoom self.zoom_x -= @adj_x self.zoom_y -= @adj_y self.zoom_x = [self.zoom_x, @zoom_max_x].max if @adj_x > 0 self.zoom_x = [self.zoom_x, @zoom_max_x].min if @adj_x < 0 self.zoom_y = [self.zoom_y, @zoom_max_y].max if @adj_x > 0 self.zoom_y = [self.zoom_y, @zoom_max_y].min if @adj_x < 0 end #-------------------------------------------------------------------------- # * update_speed #-------------------------------------------------------------------------- def update_speed duration = @wait * 100.0 / @base case duration when 66...100 @speed = (duration - 81) * 10 / @base when 33...66 @speed = (duration - 50) * 10 / @base when 0...33 @speed = (duration - 16) * 10 / @base end end #-------------------------------------------------------------------------- # * update_move #-------------------------------------------------------------------------- def update_move self.x += @move_x self.y += @move_y + (@gravity * @speed) size_value = (@exw / 4) * @size * (self.zoom_x - 1) self.ox = @base_x + (size_value / self.zoom_x) self.oy = @base_y + ((@base_y - (@base_y / self.zoom_y)) / 2) end #-------------------------------------------------------------------------- # * update_opacity #-------------------------------------------------------------------------- def update_opacity case @wait when 1..10 self.opacity -= 25 when (@base - 10)..@base self.opacity += 25 when 0 self.dispose else self.opacity = 255 end end end