Broken Messiah 20 Report post Posted September 6, 2009 Okay, I know that I seem to be on this part of the forum a lot, and i feel sort of bad about the fact that I ask for alot, yet give nothing generally,( though i am working on some more graphic resources). What I need: 1) Active Time Battle: Kinda like when a battle starts, depending on someone's Mobility, they could choose to attack first. 2) Upgradable Weapons\Armor: "The Car Shop kinda thing" Where you could select a weapon\armor and increase\decrease it's stats. Like Forging in Fire Emblem" Shadow Dragon" 3) Equipable Battlers: I have little expectation of finding this, but in theory you would be able to enter a "Garage, or Base" and change what kind of Knightmare (From Code Geass) you pilot and then be able to use it in battle, A good addon to this is customizing the color. ------------------------------------------------------------------------------------------------- I know this is asking for a lot, so as of writing this I'm going increase my Graphic Resources Creation( I'll accept requests of anything, just message me.) What the Last kinda could look like( FRom Mech Quest'sShop) Share this post Link to post Share on other sites
Maulth 2 Report post Posted September 6, 2009 Okay, I know that I seem to be on this part of the forum a lot, and i feel sort of bad about the fact that I ask for alot, yet give nothing generally,( though i am working on some more graphic resources). What I need: 1) Active Time Battle: Kinda like when a battle starts, depending on someone's Mobility, they could choose to attack first. 2) Upgradable Weapons\Armor: "The Car Shop kinda thing" Where you could select a weapon\armor and increase\decrease it's stats. Like Forging in Fire Emblem" Shadow Dragon" 3) Equipable Battlers: I have little expectation of finding this, but in theory you would be able to enter a "Garage, or Base" and change what kind of Knightmare (From Code Geass) you pilot and then be able to use it in battle, A good addon to this is customizing the color. ------------------------------------------------------------------------------------------------- I know this is asking for a lot, so as of writing this I'm going increase my Graphic Resources Creation( I'll accept requests of anything, just message me.) The second one should be very easy to find, the first one could be a simple script, and the third one I wouldn't even know where to begin. It would rely entirely on how you use your "battlers". I'll get to looking around for the first 2, and see if I can't write something for your third. Share this post Link to post Share on other sites
Polraudio 122 Report post Posted September 6, 2009 Here is my all time favorite ATB battle system. Its already by pre-configured by me for the best ATB result. No credits to me cause i just changed a few values here and there. All credit goes to Mr. Mo Got the 1st one. class Scene_Battle #-------------------------------------------------------------------------- # * Open instance variable #-------------------------------------------------------------------------- attr_reader :status_window # Status Window attr_reader :spriteset # Battle sprite attr_reader :scroll_time # Screen portable basic time attr_reader :zoom_rate # Enemy battler basic position attr_reader :drive # Camera drive attr_accessor :force # Degree of action forcing attr_accessor :camera # Present camera possession person #-------------------------------------------------------------------------- # * ATB fundamental setup #-------------------------------------------------------------------------- def atb_setup # ATB initialization # # speed : Battle speed decision. The lower the value, the faster the system # # @active : Degree of active setting # 3 : Always active state # 2 : ATB pauses when selecting skill/item # 1 : Same as 2, but pauses during target selection # 0 : Same as 1, but pauses during command window selection. # # @action : Others while acting is the fact that by their causes conduct permitted? # 3 : If by his is not incapacitation, limited to you permit # 2 : If by his has not received the damage, you permit # 1 : In addition to the state of 2, if the target has not acted, you permit # 0 : Conduct is not permitted. Until it finishes to act in order, it waits # # @anime_wait : When it makes true, during battle animation damage indicating wait catches # @damage_wait : Damage indicatory waiting (as for unit frame) # # @after_wait : At the time of ally enemy total loss, until moves to next processing, waiting # [a, b] a) At the time of party total loss, b) At time of enemy total loss (unit frame) # # @enemy_speed : Thought speed of enemy. If 1 immediately conduct. # In every frame, conduct is caused with the probability of 1/@enemy_speed # # @force : With forced action forced condition at time of skill use # 2: As for skill everything not to reside permanently, by all means immediately execution # 1: As for independent skill to reside permanently, only cooperation skill immediately execution # 0: All the skill permanent residence just are done # # ($scene.force = Usually by making x, from the script of the event modification possibility) # # CAMERA DRIVE SYSTEM: This system moves the Camera POV to the currently moving battler # @drive : Camera drive system ON/OFF. When true, drive ON, when false drive OFF # @scroll_time : Time it takes to scroll/move the camera POV during battle # # @zoom_rate = [i, j] : Zoom ratio of enemy # i) When arranging in the picture first section, enlargement ratio # j) When arranging in the picture lowest section, enlargement ratio # 1 When liking to make time, 1.0 be sure to set with decimal speed = 200 # IN FRAMES / FOR ATB SYSTEM @active = 3 # Active Setting (Range of 0 - 3) @action = 3 # Action Setting (Range of 0 - 3) @anime_wait = false # @damage_wait = 10 # @after_wait = [80, 0] # @enemy_speed = 30 # @force = 2 # @drive = true # Turns camera system on/off @scroll_time = 5 # Speed of camera system @zoom_rate = [0.2, 1.0] # Controls perspective of battlers on screen @help_time = 40 # @escape == false # @camera = nil # Used by system: Determines camera @max = 0 # @turn_cnt = 0 # Turns @help_wait = 0 # @action_battlers = [] # Used by system to hold battlers @synthe = [] # Used by system: For Cooperative Skills & such @spell_p = {} # @spell_e = {} # @command_a = false # @command = [] # @party = false # for battler in $game_party.actors + $game_troop.enemies spell_reset(battler) battler.at = battler.agi * rand(speed / 2) battler.damage_pop = {} battler.damage = {} battler.damage_sp = {} battler.critical = {} battler.recover_hp = {} battler.recover_sp = {} battler.state_p = {} battler.state_m = {} battler.animation = [] if battler.is_a?(Game_Actor) @max += battler.agi end end @max *= speed @max /= $game_party.actors.size for battler in $game_party.actors + $game_troop.enemies battler.atp = 100 * battler.at / @max end end #-------------------------------------------------------------------------- # * Full AT Gauge SE #-------------------------------------------------------------------------- def fullat_se Audio.se_play("Audio/SE/005-system05", 80, 100) end #-------------------------------------------------------------------------- # * Leveling Up SE #-------------------------------------------------------------------------- def levelup_se Audio.se_play("Audio/SE/056-Right02", 80, 100) end #-------------------------------------------------------------------------- # * Skill Acquisition SE #-------------------------------------------------------------------------- def skill_se Audio.se_play("Audio/SE/056-Right02", 80, 150) end end class Window_Base < Window #-------------------------------------------------------------------------- # * Draw Actor ATG # actor : Actor # x : draw spot x-coordinate # y : draw spot y-coordinate # width : draw spot width #-------------------------------------------------------------------------- def draw_actor_atg(actor, x, y, width = 144) if @at_gauge == nil # plus_x: revised x-coordinate # rate_x: revised X-coordinate as (%) # plus_y: revised y-coordinate # plus_width: revised width # rate_width: revised width as (%) # height: Vertical width # align1: Type 1 ( 0: left justify 1: center justify 2: right justify ) # align2: Type 2 ( 0: Upper stuffing 1: Central arranging 2:Lower stuffing ) # align3: Gauge type 0:Left justify 1: Right justify @plus_x = 0 @rate_x = 0 @plus_y = 16 @plus_width = 0 @rate_width = 100 @width = @plus_width + width * @rate_width / 100 @height = 16 @align1 = 0 @align2 = 1 @align3 = 0 # Gradation settings: grade1: Empty gauge grade2:Actual gauge # (0:On side gradation 1:Vertically gradation 2: Slantedly gradation) grade1 = 1 grade2 = 0 # Color setting. color1: Outermost framework, color2: Medium framework # color3: Empty framework dark color, color4: Empty framework light/write color color1 = Color.new(0, 0, 0) color2 = Color.new(255, 255, 192) color3 = Color.new(0, 0, 0, 192) color4 = Color.new(0, 0, 64, 192) # Color setting of gauge # Usually color setting of the time color5 = Color.new(0, 64, 80) color6 = Color.new(0, 128, 160) # When gauge is MAX, color setting color7 = Color.new(80, 0, 0) color8 = Color.new(240, 0, 0) # Color setting at time of cooperation skill use color9 = Color.new(80, 64, 32) color10 = Color.new(240, 192, 96) # Color setting at time of skill permanent residence color11 = Color.new(80, 0, 64) color12 = Color.new(240, 0, 192) # Drawing of gauge gauge_rect_at(@width, @height, @align3, color1, color2, color3, color4, color5, color6, color7, color8, color9, color10, color11, color12, grade1, grade2) end # Variable at substituting the width of the gauge which is drawn if actor.rtp == 0 at = (width + @plus_width) * actor.atp * @rate_width / 10000 else at = (width + @plus_width) * actor.rt * @rate_width / actor.rtp / 100 end if at > width at = width end # Revision such as the left stuffing central posture of gauge case @align1 when 1 x += (@rect_width - width) / 2 when 2 x += @rect_width - width end case @align2 when 1 y -= @height / 2 when 2 y -= @height end self.contents.blt(x + @plus_x + width * @rate_x / 100, y + @plus_y, @at_gauge, Rect.new(0, 0, @width, @height)) if @align3 == 0 rect_x = 0 else x += @width - at - 1 rect_x = @width - at - 1 end # Color setting of gauge if at == width # Gauge drawing at the time of MAX self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y, @at_gauge, Rect.new(rect_x, @height * 2, at, @height)) else if actor.rtp == 0 # Usually gauge drawing of the time self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y, @at_gauge, Rect.new(rect_x, @height, at, @height)) else if actor.spell == true #Gauge drawing at time of cooperation skill use self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y, @at_gauge, Rect.new(rect_x, @height * 3, at, @height)) else # Gauge drawing at time of skill permanent residence self.contents.blt(x + @plus_x + @width * @rate_x / 100, y + @plus_y, @at_gauge, Rect.new(rect_x, @height * 4, at, @height)) end end end end end #============================================================================== # ** Scene_Battle (part 1) #------------------------------------------------------------------------------ # This class performs battle screen processing. #============================================================================== class Scene_Battle #-------------------------------------------------------------------------- # * Main Processing #-------------------------------------------------------------------------- def main # Initialize each kind of temporary battle data $game_temp.in_battle = true $game_temp.battle_turn = 0 $game_temp.battle_event_flags.clear $game_temp.battle_abort = false $game_temp.battle_main_phase = false $game_temp.battleback_name = $game_map.battleback_name $game_temp.forcing_battler = nil # Initialize battle event interpreter $game_system.battle_interpreter.setup(nil, 0) # Prepare troop @troop_id = $game_temp.battle_troop_id $game_troop.setup(@troop_id) atb_setup # Make actor command window s1 = $data_system.words.attack s2 = $data_system.words.skill s3 = $data_system.words.guard s4 = $data_system.words.item @actor_command_window = Window_Command.new(160, [s1, s2, s3, s4]) @actor_command_window.y = 160 @actor_command_window.back_opacity = 160 @actor_command_window.active = false @actor_command_window.visible = false # Make other windows @party_command_window = Window_PartyCommand.new @help_window = Window_Help.new @help_window.back_opacity = 160 @help_window.visible = false @status_window = Window_BattleStatus.new @message_window = Window_Message.new # Make sprite set @spriteset = Spriteset_Battle.new # Initialize wait count @wait_count = 0 # Execute transition if $data_system.battle_transition == "" Graphics.transition(20) else Graphics.transition(40, "Graphics/Transitions/" + $data_system.battle_transition) end # Start pre-battle phase start_phase1 # Main loop loop do # Update game screen Graphics.update # Update input information Input.update # Frame update update # Abort loop if screen is changed if $scene != self break end end # Refresh map $game_map.refresh # Prepare for transition Graphics.freeze # Dispose of windows @actor_command_window.dispose @party_command_window.dispose @help_window.dispose @status_window.dispose @message_window.dispose if @skill_window != nil @skill_window.dispose end if @item_window != nil @item_window.dispose end if @result_window != nil @result_window.dispose end # Dispose of spriteset @spriteset.dispose # If switching to title screen if $scene.is_a?(Scene_Title) # Fade out screen Graphics.transition Graphics.freeze end # If switching from battle test to any screen other than game over screen if $BTEST and not $scene.is_a?(Scene_Gameover) $scene = nil end end #-------------------------------------------------------------------------- # * Determine Battle Win/Loss Results #-------------------------------------------------------------------------- def judge # If all dead determinant is true, or number of members in party is 0 if $game_party.all_dead? or $game_party.actors.size == 0 # If possible to lose if $game_temp.battle_can_lose # Return to BGM before battle starts $game_system.bgm_play($game_temp.map_bgm) # Battle end battle_end(2) # Return true return true end # Setting the game over flag $game_temp.gameover = true # Return true return true end # Return false if even 1 enemy exists for enemy in $game_troop.enemies if enemy.exist? return false end end # Start after battle phase (win) start_phase5 # Return true return true end #-------------------------------------------------------------------------- # * Frame renewal #-------------------------------------------------------------------------- def update # If battle event is running if $game_system.battle_interpreter.running? if @command.size > 0 @command_a = false @command = [] command_delete end @status_window.at_refresh # Update interpreter $game_system.battle_interpreter.update # If a battler which is forcing actions doesn't exist if $game_temp.forcing_battler == nil # If battle event has finished running unless $game_system.battle_interpreter.running? # Refresh status window @status_window.refresh setup_battle_event end end end # Update system (timer) and screen $game_system.update $game_screen.update # If timer has reached 0 if $game_system.timer_working and $game_system.timer == 0 # Abort battle $game_temp.battle_abort = true end # Update windows @help_window.update @party_command_window.update @actor_command_window.update @status_window.update @message_window.update # Update sprite set @spriteset.update # If transition is processing if $game_temp.transition_processing # Clear transition processing flag $game_temp.transition_processing = false # Execute transition if $game_temp.transition_name == "" Graphics.transition(20) else Graphics.transition(40, "Graphics/Transitions/" + $game_temp.transition_name) end end # If message window is showing if $game_temp.message_window_showing return end # If game over if $game_temp.gameover # Switch to game over screen $scene = Scene_Gameover.new return end # If returning to title screen if $game_temp.to_title # Switch to title screen $scene = Scene_Title.new return end # If battle is aborted if $game_temp.battle_abort # Return to BGM used before battle started $game_system.bgm_play($game_temp.map_bgm) # Battle ends battle_end(1) return end # If help window is waiting if @help_wait > 0 @help_wait -= 1 if @help_wait == 0 # Hide help window @help_window.visible = false end end # When the battler forced into action doesn't exist # while the battle event is in the midst of executing if $game_temp.forcing_battler == nil and $game_system.battle_interpreter.running? return end # Branch according to phase case @phase when 0 # AT gauge renewal phase if anime_wait_return update_phase0 end when 1 # pre-battle phase update_phase1 return when 2 # party command phase update_phase2 return when 5 # after battle phase update_phase5 return end if $scene != self return end if @phase == 0 if @command.size != 0 # Actor command phase if @command_a == false start_phase3 end update_phase3 end # If waiting if @wait_count > 0 # Decrease wait count @wait_count -= 1 return end update_phase4 end end #============================================================================== # ** Scene_Battle (part 2) #------------------------------------------------------------------------------ # This class performs battle screen processing. #============================================================================== #-------------------------------------------------------------------------- # * Frame renewal (AT gauge renewal phase) #-------------------------------------------------------------------------- def update_phase0 if $game_temp.battle_turn == 0 $game_temp.battle_turn = 1 end # If B button was pressed if @command_a == false and @party == false if Input.trigger?(Input::B) # Play cancel SE $game_system.se_play($data_system.cancel_se) @party = true end end if @party == true and ((@action > 0 and @action_battlers.empty?) or (@action == 0 and (@action_battlers.empty? or @action_battlers[0].phase == 1))) # Start party command phase start_phase2 return end # AT gauge increase processing cnt = 0 for battler in $game_party.actors + $game_troop.enemies active?(battler) if battler.rtp == 0 if battler.at >= @max if battler.is_a?(Game_Actor) if battler.inputable? unless @action_battlers.include?(battler) or @command.include?(battler) or @escape == true if battler.current_action.forcing fullat_se force_action(battler) action_start(battler) else fullat_se @command.push(battler) end end else unless @action_battlers.include?(battler) or battler == @command[0] battler.current_action.clear if @command.include?(battler) @command.delete(battler) else if battler.movable? fullat_se end end action_start(battler) end end else unless @action_battlers.include?(battler) if battler.current_action.forcing force_action(battler) action_start(battler) else if @enemy_speed != 0 if rand(@enemy_speed) == 0 number = cnt - $game_party.actors.size enemy_action(number) end else number = cnt - $game_party.actors.size enemy_action(number) end end end end else battler.at += battler.agi if battler.guarding? battler.at += battler.agi end if battler.movable? battler.atp = 100 * battler.at / @max end end else if battler.rt >= battler.rtp speller = synthe?(battler) if speller != nil battler = speller[0] end unless @action_battlers.include?(battler) if battler.is_a?(Game_Actor) fullat_se end battler.rt = battler.rtp action_start(battler) end else battler.rt += battler.agi speller = synthe?(battler) if speller != nil for spell in speller if spell != battler spell.rt += battler.agi end end end end end cnt += 1 end # Refresh AT gauge @status_window.at_refresh # Escape processing if @escape == true and ((@action > 0 and @action_battlers.empty?) or (@action == 0 and (@action_battlers.empty? or @action_battlers[0].phase == 1))) temp = false for battler in $game_party.actors if battler.inputable? temp = true end end if temp == true for battler in $game_party.actors if battler.at < @max and battler.inputable? temp = false break end end if temp == true @escape = false for battler in $game_party.actors battler.at %= @max end $game_temp.battle_main_phase = false update_phase2_escape end end end end #-------------------------------------------------------------------------- # * Start Party Command Phase #-------------------------------------------------------------------------- def start_phase2 # Shift to phase 2 @phase = 2 @party = false # Enable party command window @party_command_window.active = true @party_command_window.visible = true # Set actor to non-selecting @actor_index = -1 # Disable actor command window @actor_command_window.active = false @actor_command_window.visible = false if @command.size != 0 # Actor blink effect OFF if @active_actor != nil @active_actor.blink = false end end # Camera set @camera == "party" @spriteset.screen_target(0, 0, 1) # Clear main phase flag $game_temp.battle_main_phase = false end #-------------------------------------------------------------------------- # * Frame renewal (party command phase) #-------------------------------------------------------------------------- def update_phase2 # When C button is pushed if Input.trigger?(Input::C) # It diverges at cursor position of the party command window case @party_command_window.index when 0 # It fights # Nullifying the party command window @party_command_window.active = false @party_command_window.visible = false # Performing decision SE $game_system.se_play($data_system.decision_se) @escape = false @phase = 0 if $game_temp.battle_turn == 0 $game_temp.battle_turn = 1 end if @command_a == true # Actor command phase start start_phase3 else $game_temp.battle_main_phase = true end when 1 # It escapes # When it is not flight possible, if $game_temp.battle_can_escape == false # Performing buzzer SE $game_system.se_play($data_system.buzzer_se) return end # Performing decision SE $game_system.se_play($data_system.decision_se) @phase = 0 # Nullifying the party command window @party_command_window.active = false @party_command_window.visible = false $game_temp.battle_main_phase = true if $game_temp.battle_turn == 0 update_phase2_escape $game_temp.battle_turn = 1 for battler in $game_party.actors battler.at -= @max / 2 end return end # Performing decision SE $game_system.se_play($data_system.decision_se) @escape = true for battler in $game_party.actors @command_a = false @command.delete(battler) @action_battlers.delete(battler) skill_reset(battler) end end return end end #-------------------------------------------------------------------------- # * Frame renewal (party command phase: It escapes) #-------------------------------------------------------------------------- def update_phase2_escape # The enemy it is fast, calculating mean value enemies_agi = 0 enemies_number = 0 for enemy in $game_troop.enemies if enemy.exist? enemies_agi += enemy.agi enemies_number += 1 end end if enemies_number > 0 enemies_agi /= enemies_number end # The actor it is fast, calculating mean value actors_agi = 0 actors_number = 0 for actor in $game_party.actors if actor.exist? actors_agi += actor.agi actors_number += 1 end end if actors_number > 0 actors_agi /= actors_number end # Flight success decision success = rand(100) < 50 * actors_agi / enemies_agi # In case of flight success if success # Performing flight SE $game_system.se_play($data_system.escape_se) # You reset to BGM before the battle starting $game_system.bgm_play($game_temp.map_bgm) # Battle end battle_end(1) # In case of failure of flight else @help_window.set_text("Cannot escape", 1) @help_wait = @help_time # Clearing the action of party everyone $game_party.clear_actions # Main phase start start_phase4 end end #-------------------------------------------------------------------------- # * After battle phase start #-------------------------------------------------------------------------- def start_phase5 # It moves to phase 5 @phase = 5 # Performing battle end ME $game_system.me_play($game_system.battle_end_me) # You reset to BGM before the battle starting $game_system.bgm_play($game_temp.map_bgm) # Initializing EXP, the gold and the treasure exp = 0 gold = 0 treasures = [] if @active_actor != nil @active_actor.blink = false end # Setting the main phase flag $game_temp.battle_main_phase = true # Nullifying the party command window @party_command_window.active = false @party_command_window.visible = false # Nullifying the actor command window @actor_command_window.active = false @actor_command_window.visible = false if @skill_window != nil # Releasing the skill window @skill_window.dispose @skill_window = nil end if @item_window != nil # Releasing the item window @item_window.dispose @item_window = nil end # The help window is hidden @help_window.visible = false # Loop for enemy in $game_troop.enemies # When the enemy hides and it is not state, unless enemy.hidden # Adding acquisition EXP and the gold exp += enemy.exp gold += enemy.gold # Treasure appearance decision if rand(100) < enemy.treasure_prob if enemy.item_id > 0 treasures.push($data_items[enemy.item_id]) end if enemy.weapon_id > 0 treasures.push($data_weapons[enemy.weapon_id]) end if enemy.armor_id > 0 treasures.push($data_armors[enemy.armor_id]) end end end end # It limits the number of treasures up to 6 treasures = treasures[0..5] # EXP acquisition for i in 0...$game_party.actors.size actor = $game_party.actors[i] if actor.cant_get_exp? == false last_level = actor.level actor.exp += exp if actor.level > last_level @status_window.level_up(i) actor.damage[[actor, -1]] = "Level up!" actor.up_level = actor.level - last_level end end end # Gold acquisition $game_party.gain_gold(gold) # Treasure acquisition for item in treasures case item when RPG::Item $game_party.gain_item(item.id, 1) when RPG::Weapon $game_party.gain_weapon(item.id, 1) when RPG::Armor $game_party.gain_armor(item.id, 1) end end # Drawing up the battle result window @result_window = Window_BattleResult.new(exp, gold, treasures) # Setting wait count @phase5_wait_count = 100 end #-------------------------------------------------------------------------- # * Frame renewal (after battle phase) #-------------------------------------------------------------------------- def update_phase5 # When wait count is larger than 0, if @phase5_wait_count > 0 # Wait count is decreased @phase5_wait_count -= 1 # When wait count becomes 0, if @phase5_wait_count == 0 # Indicating the result window @result_window.visible = true # Clearing the main phase flag $game_temp.battle_main_phase = false # Refreshing the status window @status_window.refresh for actor in $game_party.actors if actor.damage.include?([actor, 0]) @phase5_wait_count = 20 actor.damage_pop[[actor, 0]] = true end if actor.damage.include?([actor, -1]) @phase5_wait_count = 20 actor.damage_pop[[actor, -1]] = true for level in actor.level - actor.up_level + 1..actor.level for skill in $data_classes[actor.class_id].learnings if level == skill.level and not actor.skill_learn?(skill.id) actor.damage[[actor, 0]] = "New Skill!" break end end end end end end return end # When C button is pushed, if Input.trigger?(Input::C) # Battle end battle_end(0) end end #============================================================================== # ** Scene_Battle (Part 3) #------------------------------------------------------------------------------ # It is the class which processes the battle picture. #============================================================================== #-------------------------------------------------------------------------- # * Actor command phase start #-------------------------------------------------------------------------- def start_phase3 if victory? return end # Clearing the main phase flag $game_temp.battle_main_phase = false @command_a = true @active_actor = @command[0] cnt = 0 for actor in $game_party.actors if actor == @active_actor @actor_index = cnt end cnt += 1 end @active_actor.blink = true unless @active_actor.inputable? @active_actor.current_action.clear phase3_next_actor return end phase3_setup_command_window # Setting of camera @camera = "command" plus = ($game_party.actors.size - 1) / 2.0 - @actor_index y = [(plus.abs - 1.5) * 10 , 0].min @spriteset.screen_target(plus * 50, y, 1.0 + y * 0.002) end #-------------------------------------------------------------------------- # * Command input end of actor #-------------------------------------------------------------------------- def phase3_next_actor @command.shift @command_a = false # Setting the main phase flag $game_temp.battle_main_phase = true # Nullifying the actor command window @actor_command_window.active = false @actor_command_window.visible = false # Blinking effect OFF of actor if @active_actor != nil @active_actor.blink = false end action_start(@active_actor) # You reset on the basis of the camera if @camera == "command" @spriteset.screen_target(0, 0, 1) end return end #-------------------------------------------------------------------------- # * Setup of actor command window #-------------------------------------------------------------------------- def phase3_setup_command_window # Nullifying the party command window @party_command_window.active = false @party_command_window.visible = false # Enabling the actor command window @actor_command_window.active = true @actor_command_window.visible = true # Setting the position of the actor command window @actor_command_window.x = @actor_index * 160 + (4 - $game_party.actors.size) * 80 # Setting the index to 0 @actor_command_window.index = 0 end #-------------------------------------------------------------------------- # * Enemy action compilation #-------------------------------------------------------------------------- def enemy_action(number) enemy = $game_troop.enemies[number] unless enemy.current_action.forcing enemy.make_action end action_start(enemy) end #-------------------------------------------------------------------------- # * Frame renewal (actor command phase) #-------------------------------------------------------------------------- def update_phase3 if victory? and @command_a command_delete @command.push(@active_actor) return end # When the enemy arrow is effective, if @enemy_arrow != nil update_phase3_enemy_select # When the actor arrow is effective, elsif @actor_arrow != nil update_phase3_actor_select # When the skill window is effective, elsif @skill_window != nil update_phase3_skill_select # When the item window is effective elsif @item_window != nil update_phase3_item_select # When the actor command window is effective, elsif @actor_command_window.active update_phase3_basic_command end end #-------------------------------------------------------------------------- # * Frame renewal (actor command phase: Basic command) #-------------------------------------------------------------------------- def update_phase3_basic_command unless @active_actor.inputable? @active_actor.current_action.clear phase3_next_actor return end # The B when button is pushed, if Input.trigger?(Input::B) and @party == false # Performing cancellation SE $game_system.se_play($data_system.cancel_se) @party = true end if @party == true and ((@action > 0 and @action_battlers.empty?) or (@action == 0 and (@action_battlers.empty? or @action_battlers[0].phase == 1))) # To party command phase start_phase2 return end # When C button is pushed, if Input.trigger?(Input::C) @party = false # It diverges at cursor position of the actor command window case @actor_command_window.index when 0 # Attack # Performing decision SE $game_system.se_play($data_system.decision_se) # Starting the selection of the enemy start_enemy_select when 1 # Skill # Performing decision SE $game_system.se_play($data_system.decision_se) # Starting the selection of skill start_skill_select when 2 # Defense # Performing decision SE $game_system.se_play($data_system.decision_se) # Setting action @active_actor.current_action.kind = 0 @active_actor.current_action.basic = 1 # To command input of the following actor phase3_next_actor when 3 # Item # Performing decision SE $game_system.se_play($data_system.decision_se) # Starting the selection of the item start_item_select end return end # Change Character if @command.size > 1 # When the R when button is pushed, if Input.trigger?(Input::R) $game_system.se_play($data_system.cursor_se) @party = false # Blinking effect OFF of actor if @active_actor != nil @active_actor.blink = false end @command.push(@command[0]) @command.shift @command_a = false # Start-up of new command window start_phase3 end # When the L when button is pushed, if Input.trigger?(Input::L) $game_system.se_play($data_system.cursor_se) @party = false # Blinking effect OFF of actor if @active_actor != nil @active_actor.blink = false end @command.unshift(@command[@command.size - 1]) @command.delete_at(@command.size - 1) @command_a = false # Start-up of new command window start_phase3 end # When the right button is pushed, if Input.trigger?(Input::RIGHT) $game_system.se_play($data_system.cursor_se) @party = false # Blinking effect OFF of actor if @active_actor != nil @active_actor.blink = false end actor = $game_party.actors[@actor_index] while actor == @command[0] or (not @command.include?(actor)) @actor_index += 1 @actor_index %= $game_party.actors.size actor = $game_party.actors[@actor_index] if actor == @command[0] break end end while actor != @command[0] @command.push(@command.shift) end @command_a = false # Start-up of new command window start_phase3 end # When the left button is pushed, if Input.trigger?(Input::LEFT) $game_system.se_play($data_system.cursor_se) @party = false # Blinking effect OFF of actor if @active_actor != nil @active_actor.blink = false end actor = $game_party.actors[@actor_index] while actor == @command[0] or (not @command.include?(actor)) @actor_index -= 1 @actor_index %= $game_party.actors.size actor = $game_party.actors[@actor_index] if actor == @command[0] break end end while actor != @command[0] @command.push(@command.shift) end @command_a = false # Start-up of new command window start_phase3 end end end #-------------------------------------------------------------------------- # * Frame renewal (actor command phase: Skill selection) #-------------------------------------------------------------------------- def update_phase3_skill_select # During command selecting when it becomes incapacitation, unless @active_actor.inputable? @active_actor.current_action.clear command_delete # To command input of the following actor phase3_next_actor return end # The skill window is put in visible state @skill_window.visible = true # Renewing the skill window @skill_window.update # The B when button is pushed, if Input.trigger?(Input::B) # Performing cancellation SE $game_system.se_play($data_system.cancel_se) # End selection of skill end_skill_select return end # When C button is pushed, if Input.trigger?(Input::C) # Acquiring the data which presently is selected in the skill window @skill = @skill_window.skill # When you cannot use, if @skill == nil or not @active_actor.skill_can_use?(@skill.id) # Performing buzzer SE $game_system.se_play($data_system.buzzer_se) return end # Performing decision SE $game_system.se_play($data_system.decision_se) # Setting action @active_actor.current_action.skill_id = @skill.id # The skill window is put in invisibility state @skill_window.visible = false # When the effective range is the enemy single unit, if @skill.scope == 1 # Starting the selection of the enemy start_enemy_select # When the effective range is the friend single unit, elsif @skill.scope == 3 or @skill.scope == 5 # Starting the selection of the actor start_actor_select # When the effective range is not the single unit, else # Setting action @active_actor.current_action.kind = 1 # End selection of skill end_skill_select # To command input of the following actor phase3_next_actor end return end end #-------------------------------------------------------------------------- # * Frame renewal (actor command phase: Item selection) #-------------------------------------------------------------------------- def update_phase3_item_select # During command selecting when it becomes incapacitation, unless @active_actor.inputable? @active_actor.current_action.clear command_delete # To command input of the following actor phase3_next_actor return end # The item window is put in visible state @item_window.visible = true # Renewing the item window @item_window.update # The B when button is pushed, if Input.trigger?(Input::B) # Performing cancellation SE $game_system.se_play($data_system.cancel_se) # End selection of item end_item_select return end #When C button is pushed, if Input.trigger?(Input::C) # Acquiring the data which presently is selected in the item window @item = @item_window.item # When you cannot use, unless $game_party.item_can_use?(@item.id) # Performing buzzer SE $game_system.se_play($data_system.buzzer_se) return end # Performing decision SE $game_system.se_play($data_system.decision_se) # Setting action @active_actor.current_action.item_id = @item.id # The item window is put in invisibility state @item_window.visible = false # When the effective range is the enemy single unit, if @item.scope == 1 # Starting the selection of the enemy start_enemy_select # When the effective range is the friend single unit, elsif @item.scope == 3 or @item.scope == 5 # Starting the selection of the actor start_actor_select # When the effective range is not the single unit, else # Setting action @active_actor.current_action.kind = 2 # End selection of item end_item_select # To command input of the following actor phase3_next_actor end return end end #-------------------------------------------------------------------------- # * Frame renewal (actor command phase: Enemy selection) #-------------------------------------------------------------------------- def update_phase3_enemy_select # During command selecting when it becomes incapacitation, unless @active_actor.inputable? # You reset on the basis of the camera if @camera == "select" @spriteset.screen_target(0, 0, 1) end @active_actor.current_action.clear command_delete # To command input of the following actor phase3_next_actor return end # Renewing the enemy arrow @enemy_arrow.update # The B when button is pushed, if Input.trigger?(Input::B) # Performing cancellation SE $game_system.se_play($data_system.cancel_se) # You reset on the basis of the camera if @camera == "select" # Setting of camera @camera = "command" plus = ($game_party.actors.size - 1) / 2.0 - @actor_index y = [(plus.abs - 1.5) * 10 , 0].min @spriteset.screen_target(plus * 50, y, 1.0 + y * 0.002) end # End selection of enemy end_enemy_select return end # When C button is pushed, if Input.trigger?(Input::C) # Performing decision SE $game_system.se_play($data_system.decision_se) # Performing decision SE @active_actor.current_action.kind = 0 @active_actor.current_action.basic = 0 @active_actor.current_action.target_index = @enemy_arrow.index # When it is in the midst of skill window indicating, if @skill_window != nil # Resetting action @active_actor.current_action.kind = 1 # End selection of skill end_skill_select end # When it is in the midst of item window indicating, if @item_window != nil # Resetting action @active_actor.current_action.kind = 2 # End selection of item end_item_select end # End selection of enemy end_enemy_select # To command input of the following actor phase3_next_actor end end #-------------------------------------------------------------------------- # * Frame renewal (actor command phase: Actor selection) #-------------------------------------------------------------------------- def update_phase3_actor_select # During command selecting when it becomes incapacitation, unless @active_actor.inputable? @active_actor.current_action.clear command_delete # To command input of the following actor phase3_next_actor return end # Renewing the actor arrow @actor_arrow.update # The B when button is pushed, if Input.trigger?(Input::B) # Performing cancellation SE $game_system.se_play($data_system.cancel_se) # End selection of actor end_actor_select return end # When C button is pushed, if Input.trigger?(Input::C) # Performing decision SE $game_system.se_play($data_system.decision_se) # Setting action @active_actor.current_action.kind = 0 @active_actor.current_action.basic = 0 @active_actor.current_action.target_index = @actor_arrow.index # End selection of actor end_actor_select # When it is in the midst of skill window indicating, if @skill_window != nil # Resetting action @active_actor.current_action.kind = 1 # End selection of skill end_skill_select end # When it is in the midst of item window indicating, if @item_window != nil # Resetting action @active_actor.current_action.kind = 2 # End selection of item end_item_select end # To command input of the following actor phase3_next_actor end end #-------------------------------------------------------------------------- # * Start of enemy selection #-------------------------------------------------------------------------- alias :start_enemy_select_rtab :start_enemy_select def start_enemy_select @camera = "select" for enemy in $game_troop.enemies if enemy.exist? zoom = 1 / enemy.zoom @spriteset.screen_target(enemy.attack_x(zoom) * 0.75, enemy.attack_y(zoom) * 0.75, zoom) break end end # Original processing start_enemy_select_rtab end #-------------------------------------------------------------------------- # * Enemy selection end #-------------------------------------------------------------------------- alias :end_enemy_select_rtab :end_enemy_select def end_enemy_select # Original processing end_enemy_select_rtab if (@action == 0 and not @action_battlers.empty?) or (@camera == "select" and (@active_actor.current_action.kind != 0 or @active_actor.animation1_id != 0)) @spriteset.screen_target(0, 0, 1) end end #-------------------------------------------------------------------------- # * Start of skill selection #-------------------------------------------------------------------------- def start_skill_select # Drawing up the skill window @skill_window = Window_Skill.new(@active_actor) # Help window association @skill_window.help_window = @help_window # Nullifying the actor command window @actor_command_window.active = false @actor_command_window.visible = false end #============================================================================== # ** Scene_Battle (Part 4) #------------------------------------------------------------------------------ # It is the class which processes the battle picture. #============================================================================== #-------------------------------------------------------------------------- # * Main phase start #-------------------------------------------------------------------------- def start_phase4 $game_temp.battle_main_phase = true end #-------------------------------------------------------------------------- # * Frame renewal (main phase) #-------------------------------------------------------------------------- def update_phase4 # When the battler who is forced action exists if $game_temp.forcing_battler != nil battler = $game_temp.forcing_battler if battler.current_action.forcing == false if @action_battlers.include?(battler) if @action > 0 or @action_battlers[0].phase == 1 @action_battlers.delete(battler) @action_battlers.push(battler) end if battler.phase == 1 battler.current_action.forcing = true force_action(battler) end else battler.current_action.forcing = true force_action(battler) action_start(battler) @action_battlers.delete(battler) @action_battlers.push(battler) end battler.at = @max battler.atp = 100 * battler.at / @max end end # When action is 1 or more, conduct is caused simultaneously for battler in @action_battlers.reverse # When it is in wait, if battler.wait > 0 # Wait count is decreased battler.wait -= 1 break if @action == 0 next end unless fin? and battler.phase < 3 and not $game_system.battle_interpreter.running? action_phase(battler) end break if @action == 0 end # When the battler who is forced action does not exist if $game_temp.forcing_battler == nil # Setting up the battle event setup_battle_event # When it is in the midst of battle event executing, if $game_system.battle_interpreter.running? return end end # The case where victory or defeat is decided processing if fin? # When being defeated, designated time wait if $game_party.all_dead? and @after_wait[0] > 0 @after_wait[0] -= 1 return end # At the time of victory, designated time wait if victory? and @after_wait[1] > 0 @after_wait[1] -= 1 return end # When battle ends, at the same time the actor is immediately before the acting, eliminating the conduct of the actor for battler in @action_battlers.reverse if battler.phase < 3 and not $game_system.battle_interpreter.running? @action_battlers.delete(battler) end end # Victory or defeat decision if @action_battlers.empty? and not $game_system.battle_interpreter.running? judge end end end #-------------------------------------------------------------------------- # * Action renewal (main phase) #-------------------------------------------------------------------------- def action_phase(battler) # When action 1 is, verification whether or not the battler while acting if @action == 1 and battler.phase <= 3 for target in battler.target speller = synthe?(target) if speller == nil # When the target is in the midst of usual acting, if @action_battlers.include?(target) if target.phase > 2 return end end else # When the target is in the midst of cooperation skill moving, for spell in speller if @action_battlers.include?(spell) if spell.phase > 2 return end end end end end end case battler.phase when 1 update_phase4_step1(battler) when 2 update_phase4_step2(battler) when 3 update_phase4_step3(battler) when 4 update_phase4_step4(battler) when 5 update_phase4_step5(battler) when 6 update_phase4_step6(battler) end end #-------------------------------------------------------------------------- # ? ?????? (??????? ???? 1 : ???????) #-------------------------------------------------------------------------- def update_phase4_step1(battler) # Already, when it is removed from battle if battler.index == nil @action_battlers.delete(battler) anime_wait_return return end speller = synthe?(battler) if speller == nil # When it is while the damage receiving unless battler.damage.empty? or @action > 2 return end # Whether or not conduct possibility decision unless battler.movable? battler.phase = 6 return end else # When it is while the damage receiving, for spell in speller unless spell.damage.empty? or @action > 2 return end # Whether or not conduct possibility decision unless spell.movable? battler.phase = 6 return end end end # At the time of skill use, permanent residence time setting # When forced action and @force 2 being, skill immediately motion if battler.current_action.kind == 1 and (not battler.current_action.forcing or @force != 2) if battler.rtp == 0 # If it is in the midst of skill residing permanently, cancellation skill_reset(battler) # Skill permanent residence time setting recite_time(battler) # Cooperation skill setting synthe_spell(battler) # When skill you reside permanently, if battler.rtp > 0 # When forced action and @force 1 being, only cooperation skill immediately motion speller = synthe?(battler) if battler.current_action.forcing and @force > 0 and speller != nil for spell in speller spell.rt = spell.rtp end else battler.blink = true if battler.current_action.forcing $game_temp.forcing_battler = nil battler.current_action.forcing = false end @action_battlers.delete(battler) return end end end end # Blinking effect OFF of actor if battler != nil battler.blink = false end speller = synthe?(battler) if speller == nil @spell_p.delete(battler) @spell_e.delete(battler) else for spell in speller spell.blink = false @spell_p.delete(spell) @spell_e.delete(spell) end end # It moves to step 2 battler.phase = 2 end #-------------------------------------------------------------------------- # * Frame renewal (main phase step 2: Action start) #-------------------------------------------------------------------------- def update_phase4_step2(battler) # If it is not forced action unless battler.current_action.forcing # When restriction [ the enemy is attacked ] [ friend attacks ] usually usually if battler.restriction == 2 or battler.restriction == 3 # Setting attack to action battler.current_action.kind = 0 battler.current_action.basic = 0 end end # It diverges with classification of action case battler.current_action.kind when 0 # Basis if fin? battler.phase = 6 return end make_basic_action_result(battler) when 1 # Skill if fin? and $data_skills[battler.current_action.skill_id].scope == 1..2 battler.phase = 6 return end make_skill_action_result(battler) when 2 # Item if fin? and $data_items[battler.current_action.item_id].scope == 1..2 battler.phase = 6 return end make_item_action_result(battler) end if battler.phase == 2 # It moves to step 3 battler.phase = 3 end end #-------------------------------------------------------------------------- # * Basic action result compilation #-------------------------------------------------------------------------- def make_basic_action_result(battler) # In case of attack if battler.current_action.basic == 0 # Setting animation ID battler.anime1 = battler.animation1_id battler.anime2 = battler.animation2_id # When the conduct side battler is the enemy if battler.is_a?(Game_Enemy) if battler.restriction == 3 target = $game_troop.random_target_enemy elsif battler.restriction == 2 target = $game_party.random_target_actor else index = battler.current_action.target_index target = $game_party.smooth_target_actor(index) end end # When the conduct side battler is the actor if battler.is_a?(Game_Actor) if battler.restriction == 3 target = $game_party.random_target_actor elsif battler.restriction == 2 target = $game_troop.random_target_enemy else index = battler.current_action.target_index target = $game_troop.smooth_target_enemy(index) end end # Setting the arrangement of the object side battler battler.target = [target] # Applying the effect of normality attack for target in battler.target target.attack_effect(battler) end return end # In case of defense if battler.current_action.basic == 1 return end # When escapes and is if battler.is_a?(Game_Enemy) and battler.current_action.basic == 2 # It escapes @help_window.set_text("Escape", 1) @help_wait = @help_time battler.escape return end # When what is not and is if battler.current_action.basic == 3 # It moves to step 6 battler.phase = 6 return end end #-------------------------------------------------------------------------- # * Object side battler setting of skill or item # scope : Effective range of skill or item #-------------------------------------------------------------------------- def set_target_battlers(scope, battler) # When the conduct side battler is the enemy, if battler.is_a?(Game_Enemy) # It diverges in the effective range case scope when 1 # Enemy single unit index =battler.current_action.target_index battler.target.push($game_party.smooth_target_actor(index)) when 2 # Whole enemy for actor in $game_party.actors if actor.exist? battler.target.push(actor) end end when 3 # Friend single unit index = battler.current_action.target_index battler.target.push($game_troop.smooth_target_enemy(index)) when 4 # Whole friend for enemy in $game_troop.enemies if enemy.exist? battler.target.push(enemy) end end when 5 # Friend single unit (HP 0) index = battler.current_action.target_index enemy = $game_troop.enemies[index] if enemy != nil and enemy.hp0? battler.target.push(enemy) end when 6 # Whole friend (HP 0) for enemy in $game_troop.enemies if enemy != nil and enemy.hp0? battler.target.push(enemy) end end when 7 # User battler.target.push(battler) end end # When the conduct side battler is the actor, if battler.is_a?(Game_Actor) # It diverges in the effective range case scope when 1 # Enemy single unit index = battler.current_action.target_index battler.target.push($game_troop.smooth_target_enemy(index)) when 2 # Whole enemy for enemy in $game_troop.enemies if enemy.exist? battler.target.push(enemy) end end when 3 # Friend single unit index = battler.current_action.target_index battler.target.push($game_party.smooth_target_actor(index)) when 4 # Whole friend for actor in $game_party.actors if actor.exist? battler.target.push(actor) end end when 5 # Friend single unit (HP 0) index = battler.current_action.target_index actor = $game_party.actors[index] if actor != nil and actor.hp0? battler.target.push(actor) end when 6 # Whole friend (HP 0) for actor in $game_party.actors if actor != nil and actor.hp0? battler.target.push(actor) end end when 7 # User battler.target.push(battler) end end end #-------------------------------------------------------------------------- # * Skill action result compilation #-------------------------------------------------------------------------- def make_skill_action_result(battler) # Acquiring skill @skill = $data_skills[battler.current_action.skill_id] # Verification whether or not it is cooperation skill, speller = synthe?(battler) # If it is not forced action unless battler.current_action.forcing # When with SP and so on is cut off and it becomes not be able to use if speller == nil unless battler.skill_can_use?(@skill.id) # It moves to step 6 battler.phase = 6 return end end end # SP consumption temp = false if speller != nil for spell in speller if spell.current_action.spell_id == 0 spell.sp -= @skill.sp_cost else spell.sp -= $data_skills[spell.current_action.spell_id].sp_cost end # Refreshing the status window status_refresh(spell) end else battler.sp -= @skill.sp_cost # Refreshing the status window status_refresh(battler) end # Setting animation ID battler.anime1 = @skill.animation1_id battler.anime2 = @skill.animation2_id # Setting common event ID battler.event = @skill.common_event_id # Setting the object side battler set_target_battlers(@skill.scope, battler) # Applying the effect of skill for target in battler.target if speller != nil damage = 0 d_result = false effective = false state_p = [] state_m = [] for spell in speller if spell.current_action.spell_id != 0 @skill = $data_skills[spell.current_action.spell_id] end effective |= target.skill_effect(spell, @skill) if target.damage[spell].class != String d_result = true damage += target.damage[spell] elsif effective effect = target.damage[spell] end state_p += target.state_p[spell] state_m += target.state_m[spell] target.damage.delete(spell) target.state_p.delete(spell) target.state_m.delete(spell) end if d_result target.damage[battler] = damage elsif effective target.damage[battler] = effect else target.damage[battler] = 0 end target.state_p[battler] = state_p target.state_m[battler] = state_m else target.skill_effect(battler, @skill) end end end #-------------------------------------------------------------------------- # * Item action result compilation #-------------------------------------------------------------------------- def make_item_action_result(battler) # Acquiring the item @item = $data_items[battler.current_action.item_id] # When with the item and so on is cut off and it becomes not be able to use unless $game_party.item_can_use?(@item.id) # It moves to step 6 battler.phase = 6 return end # In case of consumable if @item.consumable # The item which you use is decreased 1 $game_party.lose_item(@item.id, 1) end # Setting animation ID battler.anime1 = @item.animation1_id battler.anime2 = @item.animation2_id # Setting common event ID battler.event = @item.common_event_id # Deciding the object index = battler.current_action.target_index target = $game_party.smooth_target_actor(index) # Setting the object side battler set_target_battlers(@item.scope, battler) # Applying the effect of the item for target in battler.target target.item_effect(@item, battler) end end #-------------------------------------------------------------------------- # * Frame renewal (main phase step 3: Conduct side animation) #-------------------------------------------------------------------------- def update_phase4_step3(battler) # Renewal of help window. It diverges with classification of action case battler.current_action.kind when 0 # Basis if battler.current_action.basic == 1 @help_window.set_text($data_system.words.guard, 1) @help_wait = @help_time end when 1 # Skill skill = $data_skills[battler.current_action.skill_id] @help_window.set_text(skill.name, 1) @help_wait = @help_time when 2 # Item item = $data_items[battler.current_action.item_id] @help_window.set_text(item.name, 1) @help_wait = @help_time end # When conduct side animation (ID 0 is, the white flash) if battler.anime1 == 0 battler.white_flash = true battler.wait = 5 # Camera setting if battler.target[0].is_a?(Game_Enemy) camera_set(battler) end else battler.animation.push([battler.anime1, true]) speller = synthe?(battler) if speller != nil for spell in speller if spell != battler if spell.current_action.spell_id == 0 spell.animation.push([battler.anime1, true]) else skill = spell.current_action.spell_id spell.animation.push([$data_skills[skill].animation1_id, true]) spell.current_action.spell_id = 0 end end end end battler.wait = 2 * $data_animations[battler.anime1].frame_max - 10 end # It moves to step 4 battler.phase = 4 end #-------------------------------------------------------------------------- # * Frame renewal (main phase step 4: Object side animation) #-------------------------------------------------------------------------- def update_phase4_step4(battler) # Camera setting if battler.target[0].is_a?(Game_Enemy) and battler.anime1 != 0 camera_set(battler) end # Object side animation for target in battler.target target.animation.push([battler.anime2, (target.damage[battler] != "Miss")]) unless battler.anime2 == 0 battler.wait = 2 * $data_animations[battler.anime2].frame_max - 10 end end # It moves to step 5 battler.phase = 5 end #-------------------------------------------------------------------------- # * Frame renewal (main phase step 5: Damage indication) #-------------------------------------------------------------------------- def update_phase4_step5(battler) # Damage indication for target in battler.target if target.damage[battler] != nil target.damage_pop[battler] = true target.damage_effect(battler, battler.current_action.kind) battler.wait = @damage_wait # Refreshing the status window status_refresh(target) end end # It moves to step 6 battler.phase = 6 end #-------------------------------------------------------------------------- # * Frame renewal (main phase step 6: Refreshment) #-------------------------------------------------------------------------- def update_phase4_step6(battler) # The camera is reset if battler.target[0].is_a?(Game_Enemy) and @camera == battler @spriteset.screen_target(0, 0, 1) end # Skill learning if battler.target[0].is_a?(Game_Actor) and battler.current_action.kind == 1 for target in battler.target skill_learning(target, target.class_id, battler.current_action.skill_id) end end # Clearing the battler of the action forced object if battler.current_action.forcing == true and battler.current_action.force_kind == 0 and battler.current_action.force_basic == 0 and battler.current_action.force_skill_id == 0 $game_temp.forcing_battler = nil battler.current_action.forcing = false end refresh_phase(battler) speller = synthe?(battler) if speller != nil for spell in speller if spell != battler refresh_phase(spell) end end synthe_delete(speller) end # When common event ID is valid if battler.event > 0 # Setting up the event common_event = $data_common_events[battler.event] $game_system.battle_interpreter.setup(common_event.list, 0) end act = 0 for actor in $game_party.actors + $game_troop.enemies if actor.movable? act += 1 end end if @turn_cnt >= act and act > 0 @turn_cnt %= act $game_temp.battle_turn += 1 # Searching the full page of the battle event for index in 0...$data_troops[@troop_id].pages.size # Acquiring the event page page = $data_troops[@troop_id].pages[index] # When the span of this page [ turn ] is if page.span == 1 # Clearing the execution being completed flag $game_temp.battle_event_flags[index] = false end end end battler.phase = 1 @action_battlers.delete(battler) end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh_phase(battler) battler.at -= @max if battler.movable? battler.atp = 100 * battler.at / @max end spell_reset(battler) # Slip damage if battler.hp > 0 and battler.slip_damage? battler.slip_damage_effect battler.damage_pop["slip"] = true end # State natural cancellation battler.remove_states_auto # Refreshing the status window status_refresh(battler, true) unless battler.movable? return end # Turn several counts @turn_cnt += 1 end #-------------------------------------------------------------------------- # * Battler action start #-------------------------------------------------------------------------- def action_start(battler) battler.phase = 1 battler.anime1 = 0 battler.anime2 = 0 battler.target = [] battler.event = 0 @action_battlers.unshift(battler) end #-------------------------------------------------------------------------- # * Refreshing the status window #-------------------------------------------------------------------------- def status_refresh(battler, at = false) if battler.is_a?(Game_Actor) for i in 0...$game_party.actors.size if battler == $game_party.actors[i] number = i + 1 end end @status_window.refresh(number) if at == true @status_window.at_refresh(number) end end end #-------------------------------------------------------------------------- # * Animation wait judgement processing #-------------------------------------------------------------------------- def anime_wait_return if (@action_battlers.empty? or @anime_wait == false) and not $game_system.battle_interpreter.running? # When the enemy arrow is valid if @enemy_arrow != nil return [@active - 2, 0].min == 0 # When the actor arrow is valid elsif @actor_arrow != nil return [@active - 2, 0].min == 0 # When the skill window is valid elsif @skill_window != nil return [@active - 3, 0].min == 0 # When the item window is valid elsif @item_window != nil return [@active - 3, 0].min == 0 # When the actor command window is valid elsif @actor_command_window.active return [@active - 1, 0].min == 0 else return true end else return false end end #-------------------------------------------------------------------------- # * Actor command elimination judgement #-------------------------------------------------------------------------- def command_delete # When the enemy arrow is valid if @enemy_arrow != nil end_enemy_select # When the actor is valid elsif @actor_arrow != nil end_actor_select end # When the skill window is valid if @skill_window != nil end_skill_select # When the item window is valid elsif @item_window != nil end_item_select end # When the actor command window is valid if @actor_command_window.active @command.shift @command_a = false # Setting the main phase flag $game_temp.battle_main_phase = true # Hides the actor command window when it is invalid @actor_command_window.active = false @actor_command_window.visible = false # Blinking effect OFF of actor if @active_actor != nil @active_actor.blink = false end end end #-------------------------------------------------------------------------- # * Forcing action setting #-------------------------------------------------------------------------- def force_action(battler) battler.current_action.kind = battler.current_action.force_kind battler.current_action.basic = battler.current_action.force_basic battler.current_action.skill_id = battler.current_action.force_skill_id battler.current_action.force_kind = 0 battler.current_action.force_basic = 0 battler.current_action.force_skill_id = 0 end #-------------------------------------------------------------------------- # * Camera set #-------------------------------------------------------------------------- def camera_set(battler) @camera = battler if battler.target.size == 1 if battler.current_action.kind == 0 zoom = 1.2 / battler.target[0].zoom elsif synthe?(battler) == nil zoom = 1.5 / battler.target[0].zoom else zoom = 2.0 / battler.target[0].zoom end @spriteset.screen_target(battler.target[0].attack_x(zoom), battler.target[0].attack_y(zoom), zoom) else @spriteset.screen_target(0, 0, 0.75) end end #-------------------------------------------------------------------------- # * Skill permanent residence time compilation #-------------------------------------------------------------------------- def recite_time(battler) end #-------------------------------------------------------------------------- # * Cooperation skill distinction #-------------------------------------------------------------------------- def synthe_spell(battler) end #-------------------------------------------------------------------------- # * Skill learning system #-------------------------------------------------------------------------- def skill_learning(actor, class_id, skill_id) end #-------------------------------------------------------------------------- # * Conduct possible decision #-------------------------------------------------------------------------- def active?(battler) speller = synthe?(battler) if speller != nil if synthe_delete?(speller) return false end else unless battler.inputable? spell_reset(battler) unless battler.movable? battler.atp = 0 return false end end if battler.current_action.forcing spell_reset(battler) end end return true end #-------------------------------------------------------------------------- # * During synthesis skill residing permanently? #-------------------------------------------------------------------------- def synthe?(battler) for speller in @synthe if speller.include?(battler) return speller end end return nil end #-------------------------------------------------------------------------- # * Synthesis skill elimination judgement #-------------------------------------------------------------------------- def synthe_delete?(speller) for battler in speller if not battler.inputable? and dead_ok?(battler) synthe_delete(speller) return true end end return false end #-------------------------------------------------------------------------- # * Synthesis skill elimination #-------------------------------------------------------------------------- def synthe_delete(speller) for battler in speller spell_reset(battler) if dead_ok?(battler) @action_battlers.delete(battler) end end @synthe.delete(speller) end #-------------------------------------------------------------------------- # * Cooperation the skill permanent residence cancellation which is included #-------------------------------------------------------------------------- def skill_reset(battler) speller = synthe?(battler) if speller != nil synthe_delete(speller) else spell_reset(battler) end end #-------------------------------------------------------------------------- # * Skill permanent residence cancellation #-------------------------------------------------------------------------- def spell_reset(battler) battler.rt = 0 battler.rtp = 0 battler.blink = false battler.spell = false battler.current_action.spell_id = 0 @spell_p.delete(battler) @spell_e.delete(battler) end #-------------------------------------------------------------------------- # * Battle end decision #-------------------------------------------------------------------------- def fin? return (victory? or $game_party.all_dead? or $game_party.actors.size == 0) end #-------------------------------------------------------------------------- # * Enemy total destruction decision #-------------------------------------------------------------------------- def victory? for battler in $game_troop.enemies if not battler.hidden and (battler.rest_hp > 0 or battler.immortal or battler.damage_pop.size > 0) return false end end return true end #-------------------------------------------------------------------------- # * Death permission decision #-------------------------------------------------------------------------- def dead_ok?(battler) speller = synthe?(battler) if speller == nil if @action_battlers.include?(battler) if battler.phase > 2 return false end end else for battler in speller if @action_battlers.include?(battler) if battler.phase > 2 return false end end end end return true end end #============================================================================== # ** Game_Actor #------------------------------------------------------------------------------ # It is the class which handles the actor. This class Game_Actors class # ($game_actors) is used in inside, Game_Party class ($game_party) from is # referred to. #============================================================================== class Game_Actor < Game_Battler #-------------------------------------------------------------------------- # * Acquisition in battle picture X coordinate #-------------------------------------------------------------------------- def screen_x # Calculating X coordinate from line order inside the party, it returns if self.index != nil return self.index * 160 + (4 - $game_party.actors.size) * 80 + 80 else return 0 end end end #============================================================================== # ** Spriteset_Battle #------------------------------------------------------------------------------ # It is the class which collected the sprite of the battle picture. This class # is used inside Scene_Battle ?? ?. #============================================================================== class Spriteset_Battle #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_reader :real_x # X coordinate revision (presently value) attr_reader :real_y # Y coordinate revision (presently value) attr_reader :real_zoom # Enlargement ratio (presently value) #-------------------------------------------------------------------------- # * Object initialization #-------------------------------------------------------------------------- def initialize # Drawing up the viewport @viewport1 = Viewport.new(0, 0, 640, 480) @viewport2 = Viewport.new(0, 0, 640, 480) @viewport3 = Viewport.new(0, 0, 640, 480) @viewport4 = Viewport.new(0, 0, 640, 480) @viewport2.z = 101 @viewport3.z = 200 @viewport4.z = 5000 @wait = 0 @real_x = 0 @real_y = 0 @real_zoom = 1.0 @target_x = 0 @target_y = 0 @target_zoom = 1.0 @gap_x = 0 @gap_y = 0 @gap_zoom = 0.0 # Make battleback sprite @battleback_sprite = Sprite.new(@viewport1) # Drawing up enemy sprite @enemy_sprites = [] for enemy in $game_troop.enemies.reverse @enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy)) end # Drawing up actor sprite @actor_sprites = [] @actor_sprites.push(Sprite_Battler.new(@viewport2)) @actor_sprites.push(Sprite_Battler.new(@viewport2)) @actor_sprites.push(Sprite_Battler.new(@viewport2)) @actor_sprites.push(Sprite_Battler.new(@viewport2)) # Drawing up the weather @weather = RPG::Weather.new(@viewport1) # Drawing up picture sprite @picture_sprites = [] for i in 51..100 @picture_sprites.push(Sprite_Picture.new(@viewport3, $game_screen.pictures[i])) end # Drawing up timer sprite @timer_sprite = Sprite_Timer.new # Frame renewal update end #-------------------------------------------------------------------------- # * Frame renewal #-------------------------------------------------------------------------- def update # Contents of actor sprite renewal (in replacement of actor correspondence) @actor_sprites[0].battler = $game_party.actors[0] @actor_sprites[1].battler = $game_party.actors[1] @actor_sprites[2].battler = $game_party.actors[2] @actor_sprites[3].battler = $game_party.actors[3] # When file name of the battle back is different from present ones, if @battleback_name != $game_temp.battleback_name make_battleback end # Scroll of picture screen_scroll # Position revision of monster for enemy in $game_troop.enemies enemy.real_x = @real_x enemy.real_y = @real_y enemy.real_zoom = @real_zoom end # Renewing battler sprite for sprite in @enemy_sprites + @actor_sprites sprite.update end # Renewing weather graphics @weather.type = $game_screen.weather_type @weather.max = $game_screen.weather_max @weather.update # Renewing picture sprite for sprite in @picture_sprites sprite.update end # Renewing timer sprite @timer_sprite.update # Setting the color tone and shake position of the picture @viewport1.tone = $game_screen.tone @viewport1.ox = $game_screen.shake # Setting the flash color of the picture @viewport4.color = $game_screen.flash_color # Renewing the viewport @viewport1.update @viewport2.update @viewport4.update end #-------------------------------------------------------------------------- # * Setting of battle background #-------------------------------------------------------------------------- def make_battleback @battleback_name = $game_temp.battleback_name if @battleback_sprite.bitmap != nil @battleback_sprite.bitmap.dispose end @battleback_sprite.bitmap = RPG::Cache.battleback(@battleback_name) if @battleback_sprite.bitmap.width == 640 and @battleback_sprite.bitmap.height == 320 @battleback_sprite.src_rect.set(0, 0, 1280, 640) @base_zoom = 2.0 @battleback_sprite.zoom_x = @base_zoom @battleback_sprite.zoom_y = @base_zoom @real_y = 4 @battleback_sprite.x = 320 @battleback_sprite.y = @real_y @battleback_sprite.ox = @battleback_sprite.bitmap.width / 2 @battleback_sprite.oy = @battleback_sprite.bitmap.height / 4 elsif @battleback_sprite.bitmap.width == 640 and @battleback_sprite.bitmap.height == 480 @battleback_sprite.src_rect.set(0, 0, 960, 720) @base_zoom = 1.5 @battleback_sprite.zoom_x = @base_zoom @battleback_sprite.zoom_y = @base_zoom @battleback_sprite.x = 320 @battleback_sprite.y = 0 @battleback_sprite.ox = @battleback_sprite.bitmap.width / 2 @battleback_sprite.oy = @battleback_sprite.bitmap.height / 4 else @battleback_sprite.src_rect.set(0, 0, @battleback_sprite.bitmap.width, @battleback_sprite.bitmap.height) @base_zoom = 1.0 @battleback_sprite.zoom_x = @base_zoom @battleback_sprite.zoom_y = @base_zoom @battleback_sprite.x = 320 @battleback_sprite.y = 0 @battleback_sprite.ox = @battleback_sprite.bitmap.width / 2 @battleback_sprite.oy = @battleback_sprite.bitmap.height / 4 end end #-------------------------------------------------------------------------- # * Position enlargement ratio setting of scroll goal of picture #-------------------------------------------------------------------------- def screen_target(x, y, zoom) return unless $scene.drive @wait = $scene.scroll_time @target_x = x @target_y = y @target_zoom = zoom screen_over @gap_x = @target_x - @real_x @gap_y = @target_y - @real_y @gap_zoom = @target_zoom - @real_zoom end #-------------------------------------------------------------------------- # * Scroll of picture #-------------------------------------------------------------------------- def screen_scroll if @wait > 0 @real_x = @target_x - @gap_x * (@wait ** 2) / ($scene.scroll_time ** 2) @real_y = @target_y - @gap_y * (@wait ** 2) / ($scene.scroll_time ** 2) @real_zoom = @target_zoom - @gap_zoom * (@wait ** 2) / ($scene.scroll_time ** 2) @battleback_sprite.x = 320 + @real_x @battleback_sprite.y = @real_y @battleback_sprite.zoom_x = @base_zoom * @real_zoom @battleback_sprite.zoom_y = @base_zoom * @real_zoom @battleback_sprite.ox = @battleback_sprite.bitmap.width / 2 @battleback_sprite.oy = @battleback_sprite.bitmap.height / 4 @wait -= 1 end end #-------------------------------------------------------------------------- # * When the screen goes outside the picture, revision processing #-------------------------------------------------------------------------- def screen_over width = @battleback_sprite.bitmap.width * @base_zoom * @target_zoom / 2 unless 324 + @target_x > width and 324 - @target_x > width if 324 + @target_x > width @target_x = width - 324 elsif 324 - @target_x > width @target_x = 324 - width end end height = @battleback_sprite.bitmap.height * @base_zoom * @target_zoom / 4 unless @target_y > height - 4 and 484 - @target_y > 3 * height if @target_y > height - 4 @target_y = height - 4 elsif 484 - @target_y > 3 * height @target_y = 484 - 3 * height end end end end #============================================================================== # ** Game_Battler (Part 1) #------------------------------------------------------------------------------ # It is the class which handles the battler. This class is used as superclass # of Game_Actor class and Game_Enemy ?? ?. #============================================================================== class Game_Battler #-------------------------------------------------------------------------- # * Release instance variable addition #-------------------------------------------------------------------------- attr_accessor :up_level # The frequency of levelling up attr_accessor :at # AT (time gauge) attr_accessor :atp # AT (for indication) attr_accessor :rt # RP (permanent residence gauge) attr_accessor :rtp # RP (permanent residence necessary quantity) attr_accessor :spell # In the midst of synthesis skill motion attr_accessor :recover_hp # HP recovery quantity attr_accessor :recover_sp # SP recovery quantity attr_accessor :state_p # Status abnormal arrangement attr_accessor :state_m # Status abnormal arrangement attr_accessor :damage_sp # SP damage indicatory flag attr_accessor :animation # Arrangement of animation ID and Hit attr_accessor :phase attr_accessor :wait attr_accessor :target attr_accessor :anime1 attr_accessor :anime2 attr_accessor :event #-------------------------------------------------------------------------- # * Object initialization #-------------------------------------------------------------------------- alias :initialize_rtab :initialize def initialize initialize_rtab @damage_pop = {} @damage = {} @damage_sp = {} @critical = {} @recover_hp = {} @recover_sp = {} @state_p = {} @state_m = {} @animation = [] @phase = 1 @wait = 0 @target = [] @anime1 = 0 @anime2 = 0 @event = 0 end #-------------------------------------------------------------------------- # * Existence decision #-------------------------------------------------------------------------- def exist? return (not @hidden and (@hp > 0 or @immortal or @damage.size > 0)) end #-------------------------------------------------------------------------- # * Remaining HP estimate #-------------------------------------------------------------------------- def rest_hp # Substituting reality HP to rest_hp rest_hp = @hp # All damage which the battler receives is made to reflect on rest_hp for pre_damage in @damage if pre_damage[1].is_a?(Numeric) rest_hp -= pre_damage[1] end end return rest_hp end #-------------------------------------------------------------------------- # * Cancellation of state # state_id : State ID # force : Forced cancellation flag (with processing of automatic state use) #-------------------------------------------------------------------------- def remove_state(state_id, force = false) # When this state is added, if state?(state_id) # When with the state which it is forced is added, at the same time cancellation is not forcing if @states_turn[state_id] == -1 and not force # Method end return end # When present HP 0 and option [ the state of HP 0 you regard ] it is valid if @hp == 0 and $data_states[state_id].zero_hp # Whether or not [ you regard the state of HP 0 ] there is a state in other things, decision zero_hp = false for i in @states if i != state_id and $data_states[i].zero_hp zero_hp = true end end # If you are possible to cancel aggressive failure, HP in 1 modification if zero_hp == false @hp = 1 end end unless self.movable? # Deleting state ID from @states arrangement and @states_turn hash @states.delete(state_id) @states_turn.delete(state_id) if self.movable? self.at = 0 end else # Deleting state ID from @states arrangement and @states_turn hash @states.delete(state_id) @states_turn.delete(state_id) end end # The maximum check of HP and SP @hp = [@hp, self.maxhp].min @sp = [@sp, self.maxsp].min end #-------------------------------------------------------------------------- # * Effective application of normality attack # attacker : Attack person (battler) #-------------------------------------------------------------------------- def attack_effect(attacker) # Clearing the critical flag self.critical[attacker] = false state_p[attacker] = [] state_m[attacker] = [] # First on-target hit decision hit_result = (rand(100) < attacker.hit) # In case of on-target hit if hit_result == true # Calculating the basic damage atk = [attacker.atk - self.pdef / 2, 0].max self.damage[attacker] = atk * (20 + attacker.str) / 20 # Attribute correction self.damage[attacker] *= elements_correct(attacker.element_set) self.damage[attacker] /= 100 # When the mark of the damage is correct, if self.damage[attacker] > 0 # Critical correction if rand(100) < 4 * attacker.dex / self.agi self.damage[attacker] *= 2 self.critical[attacker] = true end # Defense correction if self.guarding? self.damage[attacker] /= 2 end end # Dispersion if self.damage[attacker].abs > 0 amp = [self.damage[attacker].abs * 15 / 100, 1].max self.damage[attacker] += rand(amp+1) + rand(amp+1) - amp end # Second on-target hit decision eva = 8 * self.agi / attacker.dex + self.eva hit = self.damage[attacker] < 0 ? 100 : 100 - eva hit = self.cant_evade? ? 100 : hit hit_result = (rand(100) < hit) end # In case of on-target hit if hit_result == true # State shocking cancellation remove_states_shock # From HP damage subtraction # State change @state_changed = false states_plus(attacker, attacker.plus_state_set) states_minus(attacker, attacker.minus_state_set) # In case of miss else # Setting "Miss" to the damage self.damage[attacker] = "Miss" # Clearing the critical flag self.critical[attacker] = false end # Method end return true end #-------------------------------------------------------------------------- # * Effective application of skill # user : User of skill (battler) # skill : Skill #-------------------------------------------------------------------------- def skill_effect(user, skill) # Clearing the critical flag self.critical[user] = false state_p[user] = [] state_m[user] = [] # Effective range of skill with friend of HP 1 or more, your own HP 0, # Or when the effective range of skill with the friend of HP 0, your own HP are 1 or more if ((skill.scope == 3 or skill.scope == 4) and self.hp == 0) or ((skill.scope == 5 or skill.scope == 6) and self.hp >= 1) # Method end return false end # Clearing the effective flag effective = false # When common event ID is valid setting the effective flag effective |= skill.common_event_id > 0 # First on-target hit decision hit = skill.hit if skill.atk_f > 0 hit *= user.hit / 100 end hit_result = (rand(100) < hit) # In case of uncertain skill setting the effective flag effective |= hit < 100 # In case of on-target hit if hit_result == true # Calculating power power = skill.power + user.atk * skill.atk_f / 100 if power > 0 power -= self.pdef * skill.pdef_f / 200 power -= self.mdef * skill.mdef_f / 200 power = [power, 0].max end # Calculating magnification ratio rate = 20 rate += (user.str * skill.str_f / 100) rate += (user.dex * skill.dex_f / 100) rate += (user.agi * skill.agi_f / 100) rate += (user.int * skill.int_f / 100) # Calculating the basic damage self.damage[user] = power * rate / 20 # Attribute correction self.damage[user] *= elements_correct(skill.element_set) self.damage[user] /= 100 # When the mark of the damage is correct if self.damage[user] > 0 # Defense correction if self.guarding? self.damage[user] /= 2 end end # Dispersion if skill.variance > 0 and self.damage[user].abs > 0 amp = [self.damage[user].abs * skill.variance / 100, 1].max self.damage[user] += rand(amp+1) + rand(amp+1) - amp end # Second on-target hit decision eva = 8 * self.agi / user.dex + self.eva hit = self.damage[user] < 0 ? 100 : 100 - eva * skill.eva_f / 100 hit = self.cant_evade? ? 100 : hit hit_result = (rand(100) < hit) # In case of uncertain skill setting the effective flag effective |= hit < 100 end # In case of on-target hit if hit_result == true # In case of physical attack other than power 0 if skill.power != 0 and skill.atk_f > 0 # State shocking cancellation remove_states_shock # Setting the effective flag effective = true end # The fluctuation decision of HP last_hp = [[self.hp - self.damage[user], self.maxhp].min, 0].max # Effective decision effective |= self.hp != last_hp # State change @state_changed = false effective |= states_plus(user, skill.plus_state_set) effective |= states_minus(user, skill.minus_state_set) unless $game_temp.in_battle self.damage_effect(user, 1) end # When power 0 is, if skill.power == 0 # Setting the null line to the damage self.damage[user] = "" # When there is no change in the state, unless @state_changed # Setting "Miss" to the damage self.damage[user] = "Miss" end end # In case of miss else # Setting "Miss" to the damage self.damage[user] = "Miss" end # When it is not in the midst of fighting, unless $game_temp.in_battle # Setting nil to the damage self.damage[user] = nil end # Method end return effective end #-------------------------------------------------------------------------- # * Effective application of item # item : Item #-------------------------------------------------------------------------- def item_effect(item, user = $game_party.actors[0]) # Clearing the critical flag self.critical[user] = false state_p[user] = [] state_m[user] = [] self.recover_hp[user] = 0 self.recover_sp[user] = 0 # Effective range of item with friend of HP 1 or more, your own HP 0, # Or when the effective range of the item with the friend of HP 0, your own HP are 1 or more, if ((item.scope == 3 or item.scope == 4) and self.hp == 0) or ((item.scope == 5 or item.scope == 6) and self.hp >= 1) # Method end return false end # Clearing the effective flag effective = false # When common event ID is valid setting the effective flag effective |= item.common_event_id > 0 # On-target hit decision hit_result = (rand(100) < item.hit) # In case of uncertain skill setting the effective flag effective |= item.hit < 100 # In case of on-target hit if hit_result == true # Calculating the recovery quantity self.recover_hp[user] = maxhp * item.recover_hp_rate / 100 + item.recover_hp self.recover_sp[user] = maxsp * item.recover_sp_rate / 100 + item.recover_sp if self.recover_hp[user] < 0 self.recover_hp[user] += self.pdef * item.pdef_f / 20 self.recover_hp[user] += self.mdef * item.mdef_f / 20 self.recover_hp[user] = [self.recover_hp[user], 0].min end # Attribute correction self.recover_hp[user] *= elements_correct(item.element_set) self.recover_hp[user] /= 100 self.recover_sp[user] *= elements_correct(item.element_set) self.recover_sp[user] /= 100 # Dispersion if item.variance > 0 and self.recover_hp[user].abs > 0 amp = [self.recover_hp[user].abs * item.variance / 100, 1].max self.recover_hp[user] += rand(amp+1) + rand(amp+1) - amp end if item.variance > 0 and self.recover_sp[user].abs > 0 amp = [self.recover_sp[user].abs * item.variance / 100, 1].max self.recover_sp[user] += rand(amp+1) + rand(amp+1) - amp end # When the mark of the recovery quantity is negative number if self.recover_hp[user] < 0 # Defense correction if self.guarding? self.recover_hp[user] /= 2 end end # The mark of the HP recovery quantity it reverses, sets to the value of the damage self.damage[user] = -self.recover_hp[user] # The fluctuation decision of HP and SP last_hp = [[self.hp + self.recover_hp[user], self.maxhp].min, 0].max last_sp = [[self.sp + self.recover_sp[user], self.maxsp].min, 0].max effective |= self.hp != last_hp effective |= self.sp != last_sp # State change @state_changed = false effective |= states_plus(user, item.plus_state_set) effective |= states_minus(user, item.minus_state_set) unless $game_temp.in_battle self.damage_effect(user, 2) end # When parameter rise value is valid if item.parameter_type > 0 and item.parameter_points != 0 # It diverges with parameter case item.parameter_type when 1 # MaxHP @maxhp_plus += item.parameter_points when 2 # MaxSP @maxsp_plus += item.parameter_points when 3 #Strength @str_plus += item.parameter_points when 4 # Dexterity @dex_plus += item.parameter_points when 5 # Agility @agi_plus += item.parameter_points when 6 # Intelligence @int_plus += item.parameter_points end # Setting the effective flag effective = true end # When HP recovery factor and the recovery quantity 0 is if item.recover_hp_rate == 0 and item.recover_hp == 0 # Setting the null line to the damage self.damage[user] = "" # When SP recovery factor and the recovery quantity 0, parameter rise value is invalid, if item.recover_sp_rate == 0 and item.recover_sp == 0 and (item.parameter_type == 0 or item.parameter_points == 0) # When there is no change in the state, unless @state_changed # Setting "Miss" to the damage self.damage[user] = "Miss" end end end # In case of miss else # Setting "Miss" to the damage self.damage[user] = "Miss" end # When it is not in the midst of fighting, unless $game_temp.in_battle # Setting nil to the damage self.damage[user] = nil end # Method end return effective end #-------------------------------------------------------------------------- # * State change (+) application # plus_state_set : State change (+) #-------------------------------------------------------------------------- def states_plus(battler, plus_state_set) # Clearing the effective flag effective = false # The loop (the state which is added) for i in plus_state_set # When this state is not defended, unless self.state_guard?(i) # If this state is not full, setting the effective flag effective |= self.state_full?(i) == false # When the state [ it does not resist ] is, if $data_states[i].nonresistance # Setting the state change flag @state_changed = true # Adding the state self.state_p[battler].push(i) # When this state is not full, elsif self.state_full?(i) == false # It converts degree of state validity to probability, compares with random number if rand(100) < [0,100,80,60,40,20,0][self.state_ranks[i]] # Setting the state change flag @state_changed = true # Adding the state self.state_p[battler].push(i) end end end end # Method end return effective end #-------------------------------------------------------------------------- # * State change (-) application # minus_state_set : State change (-) #-------------------------------------------------------------------------- def states_minus(battler, minus_state_set) # Clearing the effective flag effective = false # The loop (the state which is cancelled) for i in minus_state_set # If this state is added, setting the effective flag effective |= self.state?(i) # Setting the state change flag @state_changed = true # Cancelling the state self.state_m[battler].push(i) end # Method end return effective end #-------------------------------------------------------------------------- # * Damage operation #-------------------------------------------------------------------------- def damage_effect(battler, item) if item == 2 self.hp += self.recover_hp[battler] self.sp += self.recover_sp[battler] if self.recover_sp[battler] != 0 self.damage_sp[battler] = -self.recover_sp[battler] end self.recover_hp.delete(battler) self.recover_sp.delete(battler) else if self.damage[battler].class != String self.hp -= self.damage[battler] end end for i in self.state_p[battler] add_state(i) end for i in self.state_m[battler] remove_state(i) end end #-------------------------------------------------------------------------- # * Effective application of slip damage #-------------------------------------------------------------------------- def slip_damage_effect # Setting the damage self.damage["slip"] = self.maxhp / 10 # Dispersion if self.damage["slip"].abs > 0 amp = [self.damage["slip"].abs * 15 / 100, 1].max self.damage["slip"] += rand(amp+1) + rand(amp+1) - amp end # From HP damage subtraction self.hp -= self.damage["slip"] # Method end return true end end #============================================================================== # ** Game_BattleAction #------------------------------------------------------------------------------ # Action (the conduct which is in the midst of fighting) it is the class which # is handled. This class is used inside Game_Battler ?? ?. #============================================================================== class Game_BattleAction #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :spell_id # Skill ID for union magic attr_accessor :force_kind # Classification (basis/skill/item) attr_accessor :force_basic # basis (attack/defend/escape) attr_accessor :force_skill_id # Skill ID #-------------------------------------------------------------------------- # * Validity decision #-------------------------------------------------------------------------- def valid? return (not (@force_kind == 0 and @force_basic == 3)) end end #============================================================================== # ** Game_Actor #------------------------------------------------------------------------------ # It is the class which handles the actor. This class Game_Actors class # ($game_actors) is used in inside, Game_Party class ($game_party) from is # referred to. #============================================================================== class Game_Actor < Game_Battler def skill_can_use?(skill_id) return super end end #============================================================================== # ** Game_Enemy #------------------------------------------------------------------------------ # It is the class which handles the enemy. This class Game_Troop class # ($game_troop) is used in inside. #============================================================================== class Game_Enemy < Game_Battler #-------------------------------------------------------------------------- # * Public Instance Variables #-------------------------------------------------------------------------- attr_accessor :height # Height of picture attr_accessor :real_x # X-coordinate revision attr_accessor :real_y # Y-coordinate revision attr_accessor :real_zoom # Enlargement ratio #-------------------------------------------------------------------------- # * Object initialization # troop_id :Troop ID # member_index : Index of troop member #-------------------------------------------------------------------------- def initialize(troop_id, member_index) super() @troop_id = troop_id @member_index = member_index troop = $data_troops[@troop_id] @enemy_id = troop.members[@member_index].enemy_id enemy = $data_enemies[@enemy_id] @battler_name = enemy.battler_name @battler_hue = enemy.battler_hue @hp = maxhp @sp = maxsp @real_x = 0 @real_y = 0 @real_zoom = 1.0 @fly = 0 enemy.name.sub(/\\[Ff]\[([0-9]+)\]/) {@fly = $1.to_i} @hidden = troop.members[@member_index].hidden @immortal = troop.members[@member_index].immortal end alias :true_x :screen_x alias :true_y :screen_y #-------------------------------------------------------------------------- # * Acquisition in battle picture X coordinate #-------------------------------------------------------------------------- def screen_x return 320 + (true_x - 320) * @real_zoom + @real_x end #-------------------------------------------------------------------------- # * Acquisition in battle picture Y coordinate #-------------------------------------------------------------------------- def screen_y return true_y * @real_zoom + @real_y end #-------------------------------------------------------------------------- # * Acquisition in battle picture Z coordinate #-------------------------------------------------------------------------- def screen_z return true_y + @fly end #-------------------------------------------------------------------------- # * Acquisition of battle picture enlargement ratio #-------------------------------------------------------------------------- def zoom return ($scene.zoom_rate[1] - $scene.zoom_rate[0]) * (true_y + @fly) / 320 + $scene.zoom_rate[0] end #-------------------------------------------------------------------------- # * For attack and acquisition in battle picture X coordinate #-------------------------------------------------------------------------- def attack_x(z) return (320 - true_x) * z * 0.75 end #-------------------------------------------------------------------------- # * For attack and acquisition of battle picture Y-coordinate #-------------------------------------------------------------------------- def attack_y(z) return (160 - (true_y + @fly / 4) * z + @height * zoom * z / 2) * 0.75 end #-------------------------------------------------------------------------- # * Action compilation #-------------------------------------------------------------------------- def make_action # Clearing current action self.current_action.clear # When it cannot move, unless self.inputable? # Method end return end # Presently extracting effective action available_actions = [] rating_max = 0 for action in self.actions # Turn conditional verification n = $game_temp.battle_turn a = action.condition_turn_a b = action.condition_turn_b if (b == 0 and n != a) or (b > 0 and (n < 1 or n < a or n % b != a % b)) next end # HP conditional verification if self.hp * 100.0 / self.maxhp > action.condition_hp next end # Level conditional verification if $game_party.max_level < action.condition_level next end # Switch conditional verification switch_id = action.condition_switch_id if switch_id > 0 and $game_switches[switch_id] == false next end # Skill active conditional verification if action.kind == 1 unless self.skill_can_use?(action.skill_id) next end end # It corresponds to condition : Adding this action available_actions.push(action) if action.rating > rating_max rating_max = action.rating end end # Maximum rating value as 3 total calculation (as for 0 or less exclusion) ratings_total = 0 for action in available_actions if action.rating > rating_max - 3 ratings_total += action.rating - (rating_max - 3) end end # When total of rating 0 is not, if ratings_total > 0 # Drawing up random number value = rand(ratings_total) # Setting those which correspond to the random number which it drew up to current action for action in available_actions if action.rating > rating_max - 3 if value < action.rating - (rating_max - 3) self.current_action.kind = action.kind self.current_action.basic = action.basic self.current_action.skill_id = action.skill_id self.current_action.decide_random_target_for_enemy return else value -= action.rating - (rating_max - 3) end end end end end end #============================================================================== # ** Game_Party #------------------------------------------------------------------------------ # It is the class which handles the party. Information of the gold and the # item etc. is included. Instance of this ? lath is referred to being # $game_party. #============================================================================== class Game_Party #-------------------------------------------------------------------------- # * Total destruction decision #-------------------------------------------------------------------------- def all_dead? # When party number of people 0 is if $game_party.actors.size == 0 return false end # When the actor of HP 0 or more is in the party, for actor in @actors if actor.rest_hp > 0 return false end end # Total destruction return true end #-------------------------------------------------------------------------- # * Random of object actor decision # hp0 : Limits to the actor of HP 0 #-------------------------------------------------------------------------- # Original target decisive routine smooth_target_actor_rtab and name modification alias :random_target_actor_rtab :random_target_actor def random_target_actor(hp0 = false) # Initializing the roulette roulette = [] # Loop for actor in @actors # When it corresponds to condition if (not hp0 and actor.exist? and actor.rest_hp > 0) or (hp0 and actor.hp0?) # Acquiring the [ position ] of class of actor position = $data_classes[actor.class_id].position # At the time of avant-garde n = 4?At the time of medium defense n = 3?At the time rear guard n = 2 n = 4 - position # In roulette actor n time addition n.times do roulette.push(actor) end end end # When size of the roulette 0 is if roulette.size == 0 return random_target_actor_rtab(hp0) end # It turns the roulette, deciding the actor return roulette[rand(roulette.size)] end #-------------------------------------------------------------------------- # * Smooth decision of object actor # actor_index : actor index #-------------------------------------------------------------------------- # Original target decisive routine smooth_target_actor_rtab and name modification alias :smooth_target_actor_rtab :smooth_target_actor def smooth_target_actor(actor_index) # Acquiring the actor actor = @actors[actor_index] # When the actor exists if actor != nil and actor.exist? and actor.rest_hp > 0 return actor end # Loop for actor in @actors # When the actor exists if actor.exist? and actor.rest_hp > 0 return actor end end # When friend has destroyed, original target decisive routine is executed return smooth_target_actor_rtab(actor_index) end end #============================================================================== # ** Game_Troop #------------------------------------------------------------------------------ # It is the class which handles the troop. As for instance of this class with # $game_troop reference the ? it increases. #============================================================================== class Game_Troop #-------------------------------------------------------------------------- # * Random of object enemy decision # hp0 : It limits to the enemy of HP 0 #-------------------------------------------------------------------------- # Original target decisive routine random_target_enemy_rtab and name modification alias :random_target_enemy_rtab :random_target_enemy def random_target_enemy(hp0 = false) # Initializing the roulette roulette = [] # Loop for enemy in @enemies # When it corresponds to condition, if (not hp0 and enemy.exist? and enemy.rest_hp > 0) or (hp0 and enemy.hp0?) # Adding the enemy to the roulette roulette.push(enemy) end end # When size of the roulette 0 is, if roulette.size == 0 return random_target_enemy_rtab(hp0) end # It turns the roulette, deciding the enemy return roulette[rand(roulette.size)] end #-------------------------------------------------------------------------- # * Smooth decision of object enemy # enemy_index : enemy index #-------------------------------------------------------------------------- # Original target decisive routine smooth_target_enemy_rtab and name modification alias :smooth_target_enemy_rtab :smooth_target_enemy def smooth_target_enemy(enemy_index) # Acquiring the enemy enemy = @enemies[enemy_index] # When the enemy exists, if enemy != nil and enemy.exist? and enemy.rest_hp > 0 return enemy end # Loop for enemy in @enemies # When the enemy exists, if enemy.exist? and enemy.rest_hp > 0 return enemy end end # When the enemy has destroyed, it searches the enemy for the second time return smooth_target_enemy_rtab(enemy_index) end end #============================================================================== # ** Sprite_Battler #------------------------------------------------------------------------------ # It is sprite for battler indication. Instance of Game_Battler class is watched, # state of sprite changes automatically. #============================================================================== class Sprite_Battler < RPG::Sprite #-------------------------------------------------------------------------- # * Frame Renewal #-------------------------------------------------------------------------- def update super # When the battler is nil if @battler == nil self.bitmap = nil loop_animation(nil) return end # When file name or hue differs from present ones if @battler.battler_name != @battler_name or @battler.battler_hue != @battler_hue # To acquire bitmap, setting @battler_name = @battler.battler_name @battler_hue = @battler.battler_hue self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue) @width = bitmap.width @height = bitmap.height self.ox = @width / 2 self.oy = @height if @battler.is_a?(Game_Enemy) @battler.height = @height end # Aggressive failure or it hides and if state it designates opacity as 0 if @battler.dead? or @battler.hidden self.opacity = 0 end end # When animation ID differs from present ones if @battler.state_animation_id != @state_animation_id @state_animation_id = @battler.state_animation_id loop_animation($data_animations[@state_animation_id]) end # In case of the actor whom it should indicate if @battler.is_a?(Game_Actor) and @battler_visible # When being main phase, opacity is lowered a little if $game_temp.battle_main_phase self.opacity += 3 if self.opacity < 255 else self.opacity -= 3 if self.opacity > 207 end end # Blinking if @battler.blink blink_on else blink_off end # In case of invisibility unless @battler_visible # Appearance if not @battler.hidden and not @battler.dead? and (@battler.damage.size < 2 or @battler.damage_pop.size < 2) appear @battler_visible = true end end # Damage for battler in @battler.damage_pop if battler[0].class == Array if battler[0][1] >= 0 $scene.skill_se else $scene.levelup_se end damage(@battler.damage[battler[0]], false, 2) else damage(@battler.damage[battler[0]], @battler.critical[battler[0]]) end if @battler.damage_sp.include?(battler[0]) damage(@battler.damage_sp[battler[0]], @battler.critical[battler[0]], 1) @battler.damage_sp.delete(battler[0]) end @battler.damage_pop.delete(battler[0]) @battler.damage.delete(battler[0]) @battler.critical.delete(battler[0]) end # When it is visible if @battler_visible # Flight if @battler.hidden $game_system.se_play($data_system.escape_se) escape @battler_visible = false end # White Flash if @battler.white_flash whiten @battler.white_flash = false end # Animation unless @battler.animation.empty? for animation in @battler.animation.reverse animation($data_animations[animation[0]], animation[1]) @battler.animation.delete(animation) end end # Collapse if @battler.damage.empty? and @battler.dead? if $scene.dead_ok?(@battler) if @battler.is_a?(Game_Enemy) $game_system.se_play($data_system.enemy_collapse_se) else $game_system.se_play($data_system.actor_collapse_se) end collapse @battler_visible = false end end end # Setting the coordinate of sprite self.x = @battler.screen_x self.y = @battler.screen_y self.z = @battler.screen_z if @battler.is_a?(Game_Enemy) self.zoom_x = @battler.real_zoom * @battler.zoom self.zoom_y = @battler.real_zoom * @battler.zoom end end end #============================================================================== # ** Window_Base #------------------------------------------------------------------------------ # It is superclass of all windows in the game. #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # * Drawing of gauge #-------------------------------------------------------------------------- def gauge_rect_at(width, height, align3, color1, color2, color3, color4, color5, color6, color7, color8, color9, color10, color11, color12, grade1, grade2) # Framework drawing @at_gauge = Bitmap.new(width, height * 5) @at_gauge.fill_rect(0, 0, width, height, color1) @at_gauge.fill_rect(1, 1, width - 2, height - 2, color2) if (align3 == 1 and grade1 == 0) or grade1 > 0 color = color3 color3 = color4 color4 = color end if (align3 == 1 and grade2 == 0) or grade2 > 0 color = color5 color5 = color6 color6 = color color = color7 color7 = color8 color8 = color color = color9 color9 = color10 color10 = color color = color11 color11 = color12 color12 = color end if align3 == 0 if grade1 == 2 grade1 = 3 end if grade2 == 2 grade2 = 3 end end # Drawing vertically of empty gauge gradation indication @at_gauge.gradation_rect(2, 2, width - 4, height - 4, color3, color4, grade1) # Drawing of actual gauge @at_gauge.gradation_rect(2, height + 2, width- 4, height - 4, color5, color6, grade2) @at_gauge.gradation_rect(2, height * 2 + 2, width- 4, height - 4, color7, color8, grade2) @at_gauge.gradation_rect(2, height * 3 + 2, width- 4, height - 4, color9, color10, grade2) @at_gauge.gradation_rect(2, height * 4 + 2, width- 4, height - 4, color11, color12, grade2) end end #============================================================================== # ** Window_Help #------------------------------------------------------------------------------ # It is the window which indicates the item description the skill and the # status etc. of the actor. #============================================================================== class Window_Help < Window_Base #-------------------------------------------------------------------------- # * Enemy Setting # enemy : The enemy which indicates name and the state #-------------------------------------------------------------------------- def set_enemy(enemy) text = enemy.name.sub(/\\[Ff]\[([0-9]+)\]/) {""} state_text = make_battler_state_text(enemy, 112, false) if state_text != "" text += " " + state_text end set_text(text, 1) end end #============================================================================== # ** Window_BattleStatus #------------------------------------------------------------------------------ # It is the window which indicates the status of the party member in the # battle picture. #============================================================================== class Window_BattleStatus < Window_Base #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize x = (4 - $game_party.actors.size) * 80 width = $game_party.actors.size * 160 super(x, 320, width, 160) self.back_opacity = 160 @actor_window = [] for i in 0...$game_party.actors.size @actor_window.push(Window_ActorStatus.new(i, x + i * 160)) end @level_up_flags = [false, false, false, false] refresh end #-------------------------------------------------------------------------- # * Dispose #-------------------------------------------------------------------------- def dispose for window in @actor_window window.dispose end super end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh(number = 0) if number == 0 cnt = 0 for window in @actor_window window.refresh(@level_up_flags[cnt]) cnt += 1 end else @actor_window[number - 1].refresh(@level_up_flags[number - 1]) end end #-------------------------------------------------------------------------- # * AT gauge refreshment #-------------------------------------------------------------------------- def at_refresh(number = 0) if number == 0 for window in @actor_window window.at_refresh end else @actor_window[number - 1].at_refresh end end #-------------------------------------------------------------------------- # * Frame Renewal #-------------------------------------------------------------------------- def update super if self.x != (4 - $game_party.actors.size) * 80 self.x = (4 - $game_party.actors.size) * 80 self.width = $game_party.actors.size * 160 for window in @actor_window window.dispose end @actor_window = [] for i in 0...$game_party.actors.size @actor_window.push(Window_ActorStatus.new(i, x + i * 160)) end refresh end for window in @actor_window window.update end end end #============================================================================== # ** Window_ActorStatus #------------------------------------------------------------------------------ # It is the window which indicates the status of the party member respectively # in the battle picture. #============================================================================== class Window_ActorStatus < Window_Base #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize(id, x) @actor_num = id super(x, 320, 160, 160) self.contents = Bitmap.new(width - 32, height - 32) self.opacity = 0 self.back_opacity = 0 actor = $game_party.actors[@actor_num] @actor_nm = actor.name @actor_mhp = actor.maxhp @actor_msp = actor.maxsp @actor_hp = actor.hp @actor_sp = actor.sp @actor_st = make_battler_state_text(actor, 120, true) @status_window = [] for i in 0...5 @status_window.push(Window_DetailsStatus.new(actor, i, x)) end refresh(false) end #-------------------------------------------------------------------------- # * Dispose #-------------------------------------------------------------------------- def dispose for i in 0...5 @status_window[i].dispose end super end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh(level_up_flags) self.contents.clear actor = $game_party.actors[@actor_num] @status_window[0].refresh(actor) if @actor_nm != actor.name @status_window[1].refresh(actor) if @actor_mhp != actor.maxhp or @actor_hp != actor.hp @status_window[2].refresh(actor) if @actor_msp != actor.maxsp or @actor_sp != actor.sp @status_window[3].refresh(actor, level_up_flags) if @actor_st != make_battler_state_text(actor, 120, true) or level_up_flags @actor_nm = actor.name @actor_mhp = actor.maxhp @actor_msp = actor.maxsp @actor_hp = actor.hp @actor_sp = actor.sp @actor_st = make_battler_state_text(actor, 120, true) end #-------------------------------------------------------------------------- # * AT gauge refreshment #-------------------------------------------------------------------------- def at_refresh @status_window[4].refresh($game_party.actors[@actor_num]) end #-------------------------------------------------------------------------- # * Frame Renewal #-------------------------------------------------------------------------- def update for window in @status_window window.update end end end #============================================================================== # ** Window_DetailsStatus #------------------------------------------------------------------------------ # It is the window which indicates the status of the actor in individually in the battle picture. #============================================================================== class Window_DetailsStatus < Window_Base #-------------------------------------------------------------------------- # * Object Initialization #-------------------------------------------------------------------------- def initialize(actor, id, x) @status_id = id super(x, 320 + id * 26, 160, 64) self.contents = Bitmap.new(width - 32, height - 32) self.opacity = 0 self.back_opacity = 0 refresh(actor, false) end #-------------------------------------------------------------------------- # * Dispose #-------------------------------------------------------------------------- def dispose super end #-------------------------------------------------------------------------- # * Refresh #-------------------------------------------------------------------------- def refresh(actor, level_up_flags = false) self.contents.clear case @status_id when 0 draw_actor_name(actor, 4, 0) when 1 draw_actor_hp(actor, 4, 0, 120) when 2 draw_actor_sp(actor, 4, 0, 120) when 3 if level_up_flags self.contents.font.color = normal_color self.contents.draw_text(4, 0, 120, 32, "LEVEL UP!") else draw_actor_state(actor, 4, 0) end when 4 draw_actor_atg(actor, 4, 0, 120) end end #-------------------------------------------------------------------------- # * Frame renewal #-------------------------------------------------------------------------- def update #At the time of main phase opacity is lowered a little if $game_temp.battle_main_phase self.contents_opacity -= 4 if self.contents_opacity > 191 else self.contents_opacity += 4 if self.contents_opacity < 255 end end end #============================================================================== # ** Arrow_Base #------------------------------------------------------------------------------ # It is sprite for the arrow cursor indication which is used in the battle picture. # This class is used as superclass of Arrow_Enemy class and Arrow_Actor class. #============================================================================== class Arrow_Base < Sprite #-------------------------------------------------------------------------- # * Object Initialization # viewport :viewport #-------------------------------------------------------------------------- def initialize(viewport) super(viewport) self.bitmap = RPG::Cache.windowskin($game_system.windowskin_name) self.ox = 16 self.oy = 32 self.z = 2500 @blink_count = 0 @index = 0 @help_window = nil update end end #============================================================================== # ** Arrow_Enemy #------------------------------------------------------------------------------ # It is arrow cursor in order to make the enemy select. # This class succeeds Arrow_Base. #============================================================================== class Arrow_Enemy < Arrow_Base #-------------------------------------------------------------------------- # * Frame renewal #-------------------------------------------------------------------------- def update super # When it points to the enemy which does not exist, it throws $game_troop.enemies.size.times do break if self.enemy.exist? @index += 1 @index %= $game_troop.enemies.size end # The cursor right if Input.repeat?(Input::RIGHT) $game_system.se_play($data_system.cursor_se) $game_troop.enemies.size.times do @index += 1 @index %= $game_troop.enemies.size break if self.enemy.exist? end $scene.camera = "select" zoom = 1 / self.enemy.zoom $scene.spriteset.screen_target(self.enemy.attack_x(zoom) * 0.75, self.enemy.attack_y(zoom) * 0.75, zoom) end # The cursor left if Input.repeat?(Input::LEFT) $game_system.se_play($data_system.cursor_se) $game_troop.enemies.size.times do @index += $game_troop.enemies.size - 1 @index %= $game_troop.enemies.size break if self.enemy.exist? end $scene.camera = "select" zoom = 1 / self.enemy.zoom $scene.spriteset.screen_target(self.enemy.attack_x(zoom) * 0.75, self.enemy.attack_y(zoom) * 0.75, zoom) end # Setting the coordinate of sprite if self.enemy != nil self.x = self.enemy.screen_x self.y = self.enemy.screen_y end end end #============================================================================== # ** Interpreter #------------------------------------------------------------------------------ # It is the interpreter which executes event command. This class is used inside # the Game_System class and Game_Event class. #============================================================================== class Interpreter #-------------------------------------------------------------------------- # ? ????????? #-------------------------------------------------------------------------- def command_129 # Acquiring the actor actor = $game_actors[@parameters[0]] # When the actor is valid if actor != nil # It diverges with operation if @parameters[1] == 0 if @parameters[2] == 1 $game_actors[@parameters[0]].setup(@parameters[0]) end $game_party.add_actor(@parameters[0]) if $game_temp.in_battle $game_actors[@parameters[0]].at = 0 $game_actors[@parameters[0]].atp = 0 $scene.spell_reset($game_actors[@parameters[0]]) $game_actors[@parameters[0]].damage_pop = {} $game_actors[@parameters[0]].damage = {} $game_actors[@parameters[0]].damage_sp = {} $game_actors[@parameters[0]].critical = {} $game_actors[@parameters[0]].recover_hp = {} $game_actors[@parameters[0]].recover_sp = {} $game_actors[@parameters[0]].state_p = {} $game_actors[@parameters[0]].state_m = {} $game_actors[@parameters[0]].animation = [] end else $game_party.remove_actor(@parameters[0]) end end if $game_temp.in_battle $scene.status_window.update end # Continuation return true end #-------------------------------------------------------------------------- # * The increase and decrease of HP #-------------------------------------------------------------------------- alias :command_311_rtab :command_311 def command_311 command_311_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # *The increase and decrease of SP #-------------------------------------------------------------------------- alias :command_312_rtab :command_312 def command_312 command_312_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Modification of state #-------------------------------------------------------------------------- alias :command_313_rtab :command_313 def command_313 command_313_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * All recovery #-------------------------------------------------------------------------- alias :command_314_rtab :command_314 def command_314 command_314_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * The increase and decrease of EXP #-------------------------------------------------------------------------- alias :command_315_rtab :command_315 def command_315 command_315_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Increase and decrease of level #-------------------------------------------------------------------------- alias :command_316_rtab :command_316 def command_316 command_316_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Increase and decrease of parameter #-------------------------------------------------------------------------- alias :command_317_rtab :command_317 def command_317 command_317_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Modification of equipment #-------------------------------------------------------------------------- alias :command_319_rtab :command_319 def command_319 command_319_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Name modification of actor #-------------------------------------------------------------------------- alias :command_320_rtab :command_320 def command_320 command_320_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Class modification of actor #-------------------------------------------------------------------------- alias :command_321_rtab :command_321 def command_321 command_321_rtab if $game_temp.in_battle $scene.status_window.refresh end end #-------------------------------------------------------------------------- # * Indication of animation #-------------------------------------------------------------------------- def command_337 # Process iteration iterate_battler(@parameters[0], @parameters[1]) do |battler| # When the battler exists if battler.exist? # Setting animation ID battler.animation.push([@parameters[2], true]) end end # continuous return true end #-------------------------------------------------------------------------- # * Deal Damage #-------------------------------------------------------------------------- def command_338 # of the damage the value which is operated acquisition value = operate_value(0, @parameters[2], @parameters[3]) # Process iteration iterate_battler(@parameters[0], @parameters[1]) do |battler| # battler exists with if battler.exist? # HP modification battler.hp -= value # fighting if $game_temp.in_battle # damage setting battler.damage["event"] = value battler.damage_pop["event"] = true end end end if $game_temp.in_battle $scene.status_window.refresh end # continuation return true end #-------------------------------------------------------------------------- # * Forcing the action #-------------------------------------------------------------------------- def command_339 # If it is not in the midst of fighting, disregard unless $game_temp.in_battle return true end # If the number of turns 0 disregard if $game_temp.battle_turn == 0 return true end # Processing (With convenient ones, there are no times when it becomes plural) iterate_battler(@parameters[0], @parameters[1]) do |battler| # When the battler exists, if battler.exist? # Setting action battler.current_action.force_kind = @parameters[2] if battler.current_action.force_kind == 0 battler.current_action.force_basic = @parameters[3] else battler.current_action.force_skill_id = @parameters[3] end # Setting the conduct object if @parameters[4] == -2 if battler.is_a?(Game_Enemy) battler.current_action.decide_last_target_for_enemy else battler.current_action.decide_last_target_for_actor end elsif @parameters[4] == -1 if battler.is_a?(Game_Enemy) battler.current_action.decide_random_target_for_enemy else battler.current_action.decide_random_target_for_actor end elsif @parameters[4] >= 0 battler.current_action.target_index = @parameters[4] end # When action validity and [ directly execution ] is, if battler.current_action.valid? and @parameters[5] == 1 # Setting the battler of the forced object $game_temp.forcing_battler = battler # The index is advanced @index += 1 # end return false elsif battler.current_action.valid? and @parameters[5] == 0 battler.current_action.forcing = true end end end # continuation return true end end #============================================================================== # * Sprite module #------------------------------------------------------------------------------ # This module manages and controls animation. #============================================================================== module RPG class Sprite < ::Sprite def initialize(viewport = nil) super(viewport) @_whiten_duration = 0 @_appear_duration = 0 @_escape_duration = 0 @_collapse_duration = 0 @_damage = [] @_animation = [] @_animation_duration = 0 @_blink = false end def damage(value, critical, type = 0) if value.is_a?(Numeric) damage_string = value.abs.to_s else damage_string = value.to_s end bitmap = Bitmap.new(160, 48) bitmap.font.name = "Arial Black" bitmap.font.size = 32 bitmap.font.color.set(0, 0, 0) bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1) bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1) bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1) bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1) if value.is_a?(Numeric) and value < 0 if type == 0 bitmap.font.color.set(176, 255, 144) else bitmap.font.color.set(176, 144, 255) end else if type == 0 bitmap.font.color.set(255, 255, 255) else bitmap.font.color.set(255, 176, 144) end end if type == 2 bitmap.font.color.set(255, 224, 128) end bitmap.draw_text(0, 12, 160, 36, damage_string, 1) if critical string = "CRITICAL!" bitmap.font.size = 20 bitmap.font.color.set(0, 0, 0) bitmap.draw_text(-1, -1, 160, 20, string, 1) bitmap.draw_text(+1, -1, 160, 20, string, 1) bitmap.draw_text(-1, +1, 160, 20, string, 1) bitmap.draw_text(+1, +1, 160, 20, string, 1) bitmap.font.color.set(255, 255, 255) bitmap.draw_text(0, 0, 160, 20, string, 1) end num = @_damage.size if type != 2 @_damage.push([::Sprite.new, 40, 0, rand(40) - 20, rand(30) + 50]) else @_damage.push([::Sprite.new, 40, 0, rand(20) - 10, rand(20) + 60]) end @_damage[num][0].bitmap = bitmap @_damage[num][0].ox = 80 + self.viewport.ox @_damage[num][0].oy = 20 + self.viewport.oy if self.battler.is_a?(Game_Actor) @_damage[num][0].x = self.x @_damage[num][0].y = self.y - self.oy / 2 else @_damage[num][0].x = self.x + self.viewport.rect.x - self.ox + self.src_rect.width / 2 @_damage[num][0].y = self.y - self.oy * self.zoom_y / 2 + self.viewport.rect.y @_damage[num][0].zoom_x = self.zoom_x @_damage[num][0].zoom_y = self.zoom_y @_damage[num][0].z = 3000 end end def animation(animation, hit) return if animation == nil num = @_animation.size @_animation.push([animation, hit, animation.frame_max, []]) bitmap = RPG::Cache.animation(animation.animation_name, animation.animation_hue) if @@_reference_count.include?(bitmap) @@_reference_count[bitmap] += 1 else @@_reference_count[bitmap] = 1 end if @_animation[num][0].position != 3 or not @@_animations.include?(animation) for i in 0..15 sprite = ::Sprite.new sprite.bitmap = bitmap sprite.visible = false @_animation[num][3].push(sprite) end unless @@_animations.include?(animation) @@_animations.push(animation) end end update_animation(@_animation[num]) end def loop_animation(animation) return if animation == @_loop_animation dispose_loop_animation @_loop_animation = animation return if @_loop_animation == nil @_loop_animation_index = 0 animation_name = @_loop_animation.animation_name animation_hue = @_loop_animation.animation_hue bitmap = RPG::Cache.animation(animation_name, animation_hue) if @@_reference_count.include?(bitmap) @@_reference_count[bitmap] += 1 else @@_reference_count[bitmap] = 1 end @_loop_animation_sprites = [] for i in 0..15 sprite = ::Sprite.new sprite.bitmap = bitmap sprite.visible = false @_loop_animation_sprites.push(sprite) end # update_loop_animation end def dispose_damage for damage in @_damage.reverse damage[0].bitmap.dispose damage[0].dispose @_damage.delete(damage) end end def dispose_animation for anime in @_animation.reverse sprite = anime[3][0] if sprite != nil @@_reference_count[sprite.bitmap] -= 1 if @@_reference_count[sprite.bitmap] == 0 sprite.bitmap.dispose end end for sprite in anime[3] sprite.dispose end @_animation.delete(anime) end end def effect? @_whiten_duration > 0 or @_appear_duration > 0 or @_escape_duration > 0 or @_collapse_duration > 0 or @_damage.size == 0 or @_animation.size == 0 end def update super if @_whiten_duration > 0 @_whiten_duration -= 1 self.color.alpha = 128 - (16 - @_whiten_duration) * 10 end if @_appear_duration > 0 @_appear_duration -= 1 self.opacity = (16 - @_appear_duration) * 16 end if @_escape_duration > 0 @_escape_duration -= 1 self.opacity = 256 - (32 - @_escape_duration) * 10 end if @_collapse_duration > 0 @_collapse_duration -= 1 self.opacity = 256 - (48 - @_collapse_duration) * 6 end for damage in @_damage if damage[1] > 0 damage[1] -= 1 damage[4] -= 3 damage[2] -= damage[4] if self.battler.is_a?(Game_Actor) damage[0].x = self.x + (40 - damage[1]) * damage[3] / 10 damage[0].y = self.y - self.oy / 2 + damage[2] / 10 else damage[0].x = self.x + self.viewport.rect.x - self.ox + self.src_rect.width / 2 + (40 - damage[1]) * damage[3] / 10 damage[0].y = self.y - self.oy * self.zoom_y / 2 + self.viewport.rect.y + damage[2] / 10 damage[0].zoom_x = self.zoom_x damage[0].zoom_y = self.zoom_y end damage[0].z = 2960 + damage[1] damage[0].opacity = 256 - (12 - damage[1]) * 32 if damage[1] == 0 damage[0].bitmap.dispose damage[0].dispose @_damage.delete(damage) end end end for anime in @_animation if (Graphics.frame_count % 2 == 0) anime[2] -= 1 update_animation(anime) end end if @_loop_animation != nil and (Graphics.frame_count % 2 == 0) update_loop_animation @_loop_animation_index += 1 @_loop_animation_index %= @_loop_animation.frame_max end if @_blink @_blink_count = (@_blink_count + 1) % 32 if @_blink_count < 16 alpha = (16 - @_blink_count) * 6 else alpha = (@_blink_count - 16) * 6 end self.color.set(255, 255, 255, alpha) end @@_animations.clear end def update_animation(anime) if anime[2] > 0 frame_index = anime[0].frame_max - anime[2] cell_data = anime[0].frames[frame_index].cell_data position = anime[0].position animation_set_sprites(anime[3], cell_data, position) for timing in anime[0].timings if timing.frame == frame_index animation_process_timing(timing, anime[1]) end end else @@_reference_count[anime[3][0].bitmap] -= 1 if @@_reference_count[anime[3][0].bitmap] == 0 anime[3][0].bitmap.dispose end for sprite in anime[3] sprite.dispose end @_animation.delete(anime) end end def animation_set_sprites(sprites, cell_data, position) for i in 0..15 sprite = sprites[i] pattern = cell_data[i, 0] if sprite == nil or pattern == nil or pattern == -1 sprite.visible = false if sprite != nil next end sprite.visible = true sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192) if position == 3 if self.viewport != nil sprite.x = self.viewport.rect.width / 2 if $game_temp.in_battle and self.battler.is_a?(Game_Enemy) sprite.y = self.viewport.rect.height - 320 else sprite.y = self.viewport.rect.height - 160 end else sprite.x = 320 sprite.y = 240 end else sprite.x = self.x + self.viewport.rect.x - self.ox + self.src_rect.width / 2 if $game_temp.in_battle and self.battler.is_a?(Game_Enemy) sprite.y = self.y - self.oy * self.zoom_y / 2 + self.viewport.rect.y if position == 0 sprite.y -= self.src_rect.height * self.zoom_y / 4 elsif position == 2 sprite.y += self.src_rect.height * self.zoom_y / 4 end else sprite.y = self.y + self.viewport.rect.y - self.oy + self.src_rect.height / 2 sprite.y -= self.src_rect.height / 4 if position == 0 sprite.y += self.src_rect.height / 4 if position == 2 end end sprite.x += cell_data[i, 1] sprite.y += cell_data[i, 2] sprite.z = 2000 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 position != 3 sprite.zoom_x *= self.zoom_x sprite.zoom_y *= self.zoom_y end sprite.angle = cell_data[i, 4] sprite.mirror = (cell_data[i, 5] == 1) sprite.opacity = cell_data[i, 6] * self.opacity / 255.0 sprite.blend_type = cell_data[i, 7] end end def x=(x) sx = x - self.x if sx != 0 for anime in @_animation if anime[3] != nil for i in 0..15 anime[3][i].x += sx end end end if @_loop_animation_sprites != nil for i in 0..15 @_loop_animation_sprites[i].x += sx end end end super end def y=(y) sy = y - self.y if sy != 0 for anime in @_animation if anime[3] != nil for i in 0..15 anime[3][i].y += sy end end end if @_loop_animation_sprites != nil for i in 0..15 @_loop_animation_sprites[i].y += sy end end end super end end end #------------------------------------------------------------------------------ # New routine added to the Bitmap class. #============================================================================== class Bitmap #-------------------------------------------------------------------------- # * Rectangle Gradation Indicator # color1: Start color # color2: Ending color # align: 0: On side gradation # 1: Vertically gradation # 2: The gradation (intense concerning slantedly heavily note) #-------------------------------------------------------------------------- def gradation_rect(x, y, width, height, color1, color2, align = 0) if align == 0 for i in x...x + width red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1) green = color1.green + (color2.green - color1.green) * (i - x) / (width - 1) blue = color1.blue + (color2.blue - color1.blue) * (i - x) / (width - 1) alpha = color1.alpha + (color2.alpha - color1.alpha) * (i - x) / (width - 1) color = Color.new(red, green, blue, alpha) fill_rect(i, y, 1, height, color) end elsif align == 1 for i in y...y + height red = color1.red + (color2.red - color1.red) * (i - y) / (height - 1) green = color1.green + (color2.green - color1.green) * (i - y) / (height - 1) blue = color1.blue + (color2.blue - color1.blue) * (i - y) / (height - 1) alpha = color1.alpha + (color2.alpha - color1.alpha) * (i - y) / (height - 1) color = Color.new(red, green, blue, alpha) fill_rect(x, i, width, 1, color) end elsif align == 2 for i in x...x + width for j in y...y + height red = color1.red + (color2.red - color1.red) * ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 green = color1.green + (color2.green - color1.green) * ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 blue = color1.blue + (color2.blue - color1.blue) * ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 alpha = color1.alpha + (color2.alpha - color1.alpha) * ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 color = Color.new(red, green, blue, alpha) set_pixel(i, j, color) end end elsif align == 3 for i in x...x + width for j in y...y + height red = color1.red + (color2.red - color1.red) * ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 green = color1.green + (color2.green - color1.green) * ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 blue = color1.blue + (color2.blue - color1.blue) * ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 alpha = color1.alpha + (color2.alpha - color1.alpha) * ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2 color = Color.new(red, green, blue, alpha) set_pixel(i, j, color) end end end end end If you dont mean like that here is a more confusing one by the same person. http://www.rmxpunlimited.net/index.php/rmxp/rgss1-scripts/item/battle-systems/mrmos-abs-v45.html Share this post Link to post Share on other sites
Broken Messiah 20 Report post Posted September 19, 2009 I am using battlers from code geass hangyaku no lelouch ds. Can anyone help me with the third one( most importat) Share this post Link to post Share on other sites
Broken Messiah 20 Report post Posted September 19, 2009 I am using battlers from code geass hangyaku no lelouch ds. Can anyone help me with the third one( most importat) Share this post Link to post Share on other sites
