ТЕМА: Нужна помощь с Тактической боевкой (ХП)

#==============================================================================
# ** TACTICS:  Scenes
#------------------------------------------------------------------------------
#  This is a collection of scene classes
#==============================================================================
 
 
#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================
 
class Scene_Map
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :spriteset                # Spriteset
  attr_reader   :simstatus_window         # Sim Status Window
  #--------------------------------------------------------------------------
  # * Event Loop
  #--------------------------------------------------------------------------
  def event_loop
    for event in $game_map.event2.values
      if event.starting
        # Setting up the event
        $game_system.map_interpreter.setup(event.list, 0)
        loop do
          $game_system.map_interpreter.update
          # Abort loop if B button was pressed
          break if $scene != self
          # Update game screen
          Graphics.update
          # Update input information
          Input.update
          # Frame update          
          $scene.update
          break unless $game_system.map_interpreter.running?
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make sprite set
    @spriteset = Spriteset_Map.new
    # Make message window
    @message_window = Window_Message.new
    # Make status window
    @simstatus_window = Window_SimStatus.new
    $game_map.make_line(nil)
    # Transition Run
    Graphics.transition
    # Set the map refresh flag
    $game_map.need_refresh = true
    phase = 0
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # If Shift button is pressed
      if Input.press?(Input::SHIFT) == true
        @spriteset.damage_sprite.visible = true
      else
        @spriteset.damage_sprite.visible = false
        if $game_map.phase != 0
          xsave = $game_player.x
          ysave = $game_player.y
          Think(2)
          $game_map.move_clear(4)
          $game_player.moveto(xsave, ysave)
          $game_map.set_variables
        else
          # Frame update
          update
          # Abort loop if screen is changed
          break if $scene != self
          # If C button is pressed
          if Input.trigger?(Input::C)
            e = $game_map.check_event($game_player.x, $game_player.y)
            if e > 0
              $game_system.se_play($data_system.decision_se)
              $game_map.events[e].oldx = $game_map.events[e].x
              $game_map.events[e].oldy = $game_map.events[e].y
              $game_map.move_main($game_player.x, $game_player.y, $game_map.events[e].data.move_power, $game_map.events[e])
              if main_slct_goal(e) == true
                $game_map.events[e].action_end
                $game_map.set_variables
              end
              $game_map.move_clear(4)
            else
              se = RPG::AudioFile.new("057-Wrong01")
              $game_system.se_play(se)
            end
          # If B button is pressed
          elsif Input.trigger?(Input::B)
            if end_turn == true
              for event in $game_map.events.values
                if event.wait_time <= 0 && event.group & 1 != 0
                  event.wait_time = 1
                  # Defending
                  event.data.current_action.kind = 0
                  event.data.current_action.basic = 1
                  event.data.current_action.target_index = 0
                end
              end
              $game_map.set_variables
            end
          end
        end
      end
      event_loop
      # If debug mode is ON and F9 key was pressed
      if $DEBUG and Input.press?(Input::F9)
        # Set debug calling flag
        $game_temp.debug_calling = true
      end
      # Abort loop if B button was pressed
      break if $scene != self
    end
    # Prepare for transition
    Graphics.freeze
    @simstatus_window.dispose
    # Dispose of sprite set
    @spriteset.dispose
    # Dispose of message window
    @message_window.dispose
    # If switching to title screen
    if $scene.is_a?(Scene_Title)
      # Fade out screen
      Graphics.transition
      Graphics.freeze
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # Main Loop
    loop do
      # Update map, interpreter, and player order
      # (this update order is important for when conditions are fulfilled 
      # to run any event, and the player isn't provided the opportunity to
      # move in an instant)
      $game_map.update
      $game_player.update
      # Abort loop if player isn't place moving
      break unless $game_temp.player_transferring
      # Run place move
      transfer_player
      # Abort loop if transition processing
      break if $game_temp.transition_processing
    end
    # Update sprite set
    @spriteset.update
    # Update message window
    @message_window.update
    # If returning to title screen
    if $game_temp.to_title
      # Change to title screen
      $scene = Scene_Title.new
      return
    end
    # If showing menu
    call_menu if $game_temp.menu_calling
    # If showing message window
    return if $game_temp.message_window_showing
    # If player is not moving
    unless $game_player.moving?
      # If showing save menu
      call_save if $game_temp.save_calling
    end
    return
    # If encounter list isn't empty, and encounter count is 0
    if $game_player.encounter_count == 0 and $game_map.encounter_list != []
      # If event is running or encounter is not forbidden
      unless $game_system.map_interpreter.running? or
             $game_system.encounter_disabled
        # Confirm troop
        n = rand($game_map.encounter_list.size)
        troop_id = $game_map.encounter_list[n]
        # If troop is valid
        if $data_troops[troop_id] != nil
          # Set battle calling flag
          $game_temp.battle_calling = true
          $game_temp.battle_troop_id = troop_id
          $game_temp.battle_can_escape = true
          $game_temp.battle_can_lose = false
          $game_temp.battle_proc = nil
        end
      end
    end
    # If player is not moving 
    unless $game_player.moving?
      # Run calling of each screen
      if $game_temp.battle_calling
        call_battle
      elsif $game_temp.shop_calling
        call_shop
      elsif $game_temp.name_calling
        call_name
      elsif $game_temp.menu_calling
        call_menu
      elsif $game_temp.save_calling
        call_save
      elsif $game_temp.debug_calling
        call_debug
      end
    end
  end  
  #--------------------------------------------------------------------------
  # * Player Place Move
  #--------------------------------------------------------------------------
  def transfer_player
    # Clear player place move call flag
    $game_temp.player_transferring = false
    # If move destination is different than current map
    if $game_map.map_id != $game_temp.player_new_map_id
      # Set up a new map
      $game_map.setup($game_temp.player_new_map_id)
    end
    # Set up player position
    $game_player.moveto($game_temp.player_new_x, $game_temp.player_new_y)
    # Set player direction
    case $game_temp.player_new_direction
    when 2  # down
      $game_player.turn_down
    when 4  # left
      $game_player.turn_left
    when 6  # right
      $game_player.turn_right
    when 8  # up
      $game_player.turn_up
    end    
    # Straighten player position
    $game_player.straighten
    # Update map (run parallel process event)
    $game_map.update
    # Remake sprite set
    @spriteset.dispose
    @spriteset = Spriteset_Map.new
    $game_map.move_clear()
    $game_map.make_line(nil)
    # If processing transition
    if $game_temp.transition_processing
      # Clear transition processing flag
      $game_temp.transition_processing = false
      # Execute transition
      Graphics.transition(20)
    end
    # Run automatic change for BGM and BGS set on the map
    $game_map.autoplay
    # Frame reset
    Graphics.frame_reset
    # Update input information
    Input.update
  end
  #--------------------------------------------------------------------------
  # * Move Unit To Goal
  #--------------------------------------------------------------------------
  def MoveUnitToGoal(unit, nTargetX, nTargetY)
    unit.oldx = unit.x
    unit.oldy = unit.y
    route = $game_map.make_route(nTargetX, nTargetY)
    se = RPG::AudioFile.new("016-Jump02")
    for i in route
      $game_system.se_play(se)
      case i
      when 2  # Move Down
        unit.move_down
      when 3  # Move Left
        unit.move_left
      when 1  # Move Right
        unit.move_right
      when 0  # Move Up
        unit.move_up
      end
      $game_player.moveto(unit.x, unit.y)
      while unit.moving?
        # Update game screen
        Graphics.update
        # Frame update
        update_slct_goal
      end
    end
    # Defend
    unit.data.current_action.kind = 0
    unit.data.current_action.basic = 1
    unit.data.current_action.target_index = 0
  end
  #--------------------------------------------------------------------------
  # * Wait for Effect End
  #--------------------------------------------------------------------------
  def wait_for_effect_end
      # Update game screen
      Graphics.update
      # Frame Update
      update_slct_goal
    while @spriteset.effect?
      # Update game screen
      Graphics.update
      # Frame update
      update_slct_goal
    end
  end
  #--------------------------------------------------------------------------
  # * Attack
  #--------------------------------------------------------------------------
  def hpbar_move(e, enemy, skill_id)
    $game_player.moveto($game_map.events[enemy].x, $game_map.events[enemy].y)
    $game_map.events[e].turn_pos($game_map.events[enemy].x, $game_map.events[enemy].y)
    $game_map.events[enemy].turn_pos($game_map.events[e].x, $game_map.events[e].y)
    $sim_enemy = []
    $sim_enemy[0] = $game_map.events[e].data
    $sim_enemy[1] = $game_map.events[enemy].data
    oldhp = $game_map.events[enemy].data.hp
    if skill_id == 0
      $game_map.events[e].data.current_action.kind = 0
      $game_map.events[e].data.current_action.basic = 0
      $game_map.events[enemy].data.attack_effect($game_map.events[e].data)
      $sim_enemy[1].current_action.kind = 0
    elsif skill_id > 0
      $game_map.events[e].data.current_action.kind = 1
      $game_map.events[enemy].data.skill_effect($game_map.events[e].data, $data_skills[skill_id])
      $sim_enemy[0].current_action.kind = 1
      $sim_enemy[0].current_action.skill_id = skill_id
    else
      $game_map.events[e].data.current_action.kind = 2
      $game_map.events[enemy].data.item_effect($data_items[-skill_id])
      $sim_enemy[0].current_action.kind = 2
      $sim_enemy[0].current_action.item_id = -skill_id
    end
    $sim_enemy[1].damage = oldhp - $sim_enemy[1].hp
    $sim_enemy[1].new_hp = $sim_enemy[1].hp
    $sim_enemy[1].hp = oldhp
    $game_map.events[e].data.current_action.target_index = enemy
    $game_temp.battle_troop_id = 1
    # Prepare for Transition
    Graphics.freeze
    @simstatus_window.dispose
    # Dispose of spriteset
    @spriteset.dispose
    # Dispose of windows
    @message_window.dispose
    scene = $scene
    # Change to battle picture
    $scene = Scene_SimBattle.new
    $scene.main
    $scene = scene
    # Make spriteset
    @spriteset = Spriteset_Map.new
    # Make message window
    @message_window = Window_Message.new
    # Make status window
    @simstatus_window = Window_SimStatus.new
    # Execute transition
    Graphics.transition
    if $game_map.events[enemy].data.hp == 0
      $game_map.events.delete enemy
      @spriteset.dispose
      @spriteset = Spriteset_Map.new
    end
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main_slct_goal(e)
    # Main Loop
    old_x = $game_map.events[e].x
    old_y = $game_map.events[e].y
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update_slct_goal
      # If C Button is pressed
      if Input.trigger?(Input::C)
        if $game_map.events[e].group & 1 == 0 or
           $game_map.events[e].wait_time > 0
          if $game_player.x == $game_map.events[e].x and
             $game_player.y == $game_map.events[e].y
            @simstatus_window.visible = false
            scene = Scene_SimStatus.new($game_map.events[e].data)
            scene.main
            # Make status window visible
            @simstatus_window.visible = true
          else
            return false
          end
        else
          if $game_map.map_id == 50 || $game_map.map_id == 50
            if $game_map.move_action[$game_player.x, $game_player.y] & 1 == 0
              $game_variables[7] = 3
              $game_map.refresh
              event_loop
              $game_variables[7] = 0
              next
            elsif $game_player.x !=  8 || $game_player.y != 3 and
               $game_player.x !=  9 || $game_player.y != 4 and
               $game_player.x != 10 || $game_player.y != 3
              $game_variables[7] = 1
              $game_map.refresh
              event_loop
              $game_variables[7] = 0
              next
            end
          end
          if $game_map.move_action[$game_player.x, $game_player.y] & 1 != 0
            $game_system.se_play($data_system.decision_se)
            MoveUnitToGoal($game_map.events[e], $game_player.x, $game_player.y)
            return true if main_slct_cmd(e) == true
            $game_map.events[e].moveto(old_x, old_y)
          else
            se = RPG::AudioFile.new("057-Wrong01")
            $game_system.se_play(se)
          end
        end
      # if B button was pressed
      elsif Input.trigger?(Input::B)
        return false
      # If debug mode is ON and F9 key was pressed
      elsif $DEBUG and Input.press?(Input::F9)
        # Set debug calling flag  
        $game_temp.debug_calling = true
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame update
  #--------------------------------------------------------------------------
  def update_slct_goal
    # Update map and player 
    $game_map.update
    $game_player.update
    # Update spriteset
    @spriteset.update
    # Update message window
    @message_window.update
  end
  #--------------------------------------------------------------------------
  # * Main Processing for enemies
  #--------------------------------------------------------------------------
  def main_slct_enemy(e, group = 2, dist = 1)
    $game_map.move_set_distance($game_map.events[e].x, $game_map.events[e].y, 0, dist)
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update  
      update_slct_goal
      enemy = $game_map.check_event($game_player.x, $game_player.y)
      if enemy > 0 && $game_map.events[enemy].group & 7 != 0
        @simstatus_window.set_actor($game_map.events[enemy].data)
        @simstatus_window.visible = true
      else
        @simstatus_window.visible = false
      end
      # If C button was pressed
      if Input.trigger?(Input::C)
        enemy = $game_map.check_event($game_player.x, $game_player.y)
        if enemy > 0 && $game_map.events[enemy].group & group != 0 and
           distance($game_map.events[e].x, $game_map.events[e].y, $game_map.events[enemy].x, $game_map.events[enemy].y) <= dist
          $game_system.se_play($data_system.decision_se)
          return enemy
        end
        se = RPG::AudioFile.new("057-Wrong01")
        $game_system.se_play(se)
      # If B button was pressed
      elsif Input.trigger?(Input::B)
        $game_map.move_set_move
        $game_map.move_clear(0xfffd)
        # Frame Update
        update_slct_goal
        return 0
      # If debug mode is ON and F9 key was pressed
      elsif $DEBUG and Input.press?(Input::F9)
        # Set debug calling flag
        $game_temp.debug_calling = true
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Command Processing
  #--------------------------------------------------------------------------
  def main_slct_cmd(e)
    # Make actor command window
    s1 = "Attack"
    s2 = "Item"
    s3 = "Skill"
    s4 = "Status"
    s5 = "Defense"
    command_window = Window_Command.new(192, [s1,s2, s3, s4, s5])
    command_window.back_opacity = 160
    command_window.x = 20
    command_window.y = 240 - command_window.height / 2
    ret = true
    # Main Loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Update command window
      command_window.update
      # Update message window
      @message_window.update
      # If B button was pressed
      if Input.trigger?(Input::B)
        ret = false
        break
      # If C button was pressed
      elsif Input.trigger?(Input::C)
        if $game_map.map_id == 50 || $game_map.map_id == 50
          if command_window.index != 0
            $game_variables[7] = 2
            $game_map.refresh
            event_loop
            $game_variables[7] = 0
            next
          end
        end
        $game_system.se_play($data_system.decision_se)
        # Branch by command window current index
        case command_window.index
        when 0  # Attack
          command_window.visible = false
          $game_map.move_clear(2)
          enemy = main_slct_enemy(e, 2, $game_map.events[e].range) 
          if enemy != 0
            hpbar_move(e, enemy, 0)
            break
          end
          command_window.visible = true
        when 1  # Item
          command_window.visible = false
          $game_map.move_clear(2)
          break if main_slct_item(e)
          command_window.visible = true
        when 2  # Item
          command_window.visible = false
          $game_map.move_clear(2)
          break if main_slct_skill(e)
          command_window.visible = true
        when 3  # Status
          command_window.visible = false
          @simstatus_window.visible = false
          scene = Scene_SimStatus.new($game_map.events[e].data)
          scene.main
          @simstatus_window.visible = true
          command_window.visible = true
        when 4  # End
          break
        end
      end
    end
    command_window.dispose
    return ret
  end
  #--------------------------------------------------------------------------
  # * Item Processing
  #--------------------------------------------------------------------------
  def main_slct_item(e)
    # Draw the help and item windows
    if @simstatus_window.y > 320
      help_window = Window_Help.new(0)
      item_window = Window_Item.new(64)
    else
      help_window = Window_Help.new(480-64)
      item_window = Window_Item.new(480-64-256)
    end
    # Make the item window
    item_window.help_window = help_window
    ret = false
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Update the windows
      help_window.update
      item_window.update
      # If B button was pressed
      if Input.trigger?(Input::B)
        ret = false
        break
      # If C button was pressed
      elsif Input.trigger?(Input::C)
        # Get currently selected data on the item window
        item = item_window.item
        # If it can't be used
        unless $game_party.item_can_use?(item.id)
          # Play buzzer se
          $game_system.se_play($data_system.buzzer_se)
          next
        end
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Hide the windows
        item_window.visible = false
        help_window.visible = false
        $game_map.move_clear(2)
        # If effect scope is single enemy
        if item.scope == 1
          # Start enemy selection
          enemy = main_slct_enemy(e) 
          if enemy != 0
            ret = true
            break
          end
        # If effect scope is single ally
        elsif item.scope == 3 or item.scope == 5
          # Start actor selection
          unit = main_slct_enemy(e, 1)
          if unit != 0
            # Play item use SE
            $game_system.se_play(item.menu_se)
            # If consumable
            if item.consumable
              # Decrease used items by 1
              $game_party.lose_item(item.id, 1)
            end
            hpbar_move(e, unit, -item.id)
            ret = true
            break
          end
          # If effect scope is not single
        else
          ret = true
          break
        end
        item_window.visible = true
        help_window.visible = true
      end
    end
    # Dispose of windows
    help_window.dispose
    item_window.dispose
    return ret
  end
  #--------------------------------------------------------------------------
  # * Skill Processing
  #--------------------------------------------------------------------------
  def main_slct_skill(actor_index)
    # Obtain the actor
    actor = $game_map.events[actor_index].data
    # Draw the help and item windows
    if @simstatus_window.y > 320
      help_window = Window_Help.new(0)
      skill_window = Window_Skill.new(actor, 64)
    else
      help_window = Window_Help.new(480-64)
      skill_window = Window_Skill.new(actor, 480-64-256)
    end    
    # Associate help window
    skill_window.help_window = help_window
    ret = false
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Update the windows
      help_window.update
      skill_window.update
      # If the B button was pressed
      if Input.trigger?(Input::B)
        # Play cancel SE
        $game_system.se_play($data_system.cancel_se)
        # Change to menu screen
        ret = false
        break
      end
      # If the C button was pressed
      if Input.trigger?(Input::C)
        # Get currently selected data on the skill window
        skill = skill_window.skill
        # If unable to use
        if skill == nil or not actor.skill_can_use?(skill.id)
          # Play buzzer SE
          $game_system.se_play($data_system.buzzer_se)
          next
        end
        range = 0
        if skill.element_set.include?($data_system.elements.index(TACTIC_RANGE_1))
          range += 1
        end
        if skill.element_set.include?($data_system.elements.index(TACTIC_RANGE_2))
          range += 2
        end
        if skill.element_set.include?($data_system.elements.index(TACTIC_RANGE_3))
          range += 4
        end
        if skill.element_set.include?($data_system.elements.index(TACTIC_RANGE_4))
          range += 8
        end
        if skill.element_set.include?($data_system.elements.index(TACTIC_RANGE_5))
          range += 16
        end
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Hide the skill window
        skill_window.visible = false
        # If effect scope is single enemy
        if skill.scope == 1
          # Start enemy selection
          unit = main_slct_enemy(actor_index, 2, range)
          if unit != 0
            # Use up SP
            actor.sp -= skill.sp_cost
            hpbar_move(actor_index, unit, skill.id)
            ret = true
            break
          end
        # If effect scope is single actor
        elsif skill.scope == 3 or skill.scope == 5
        # Start actor selection
          unit = main_slct_enemy(actor_index, 1, range)
          if unit != 0
            # Use up SP
            actor.sp -= skill.sp_cost
            hpbar_move(actor_index, unit, skill.id)
            ret = true
            break
          end
          # If effect scope is not single
        else
          # Use up SP
          actor.sp -= skill.sp_cost
          End skill selection o
          ret = true
          break
        end
      end
    end
    # Dispose of windows
    help_window.dispose
    skill_window.dispose
    return ret
  end
  #--------------------------------------------------------------------------
  # * End turn
  #--------------------------------------------------------------------------
  def end_turn()
    if $game_map.map_id == 50 || $game_map.map_id == 50 || $game_map.map_id == 50
      $game_variables[7] = 4
      $game_map.refresh
      event_loop
      $game_variables[7] = 0
      return false
    end
    @simstatus_window.visible = false
    # Make ther command window
    s1 = "End the turn"
    s2 = "Continue"
    command_window = Window_Command.new(192, [s1, s2])
    command_window.back_opacity = 160
    command_window.x = 20
    command_window.y = 88
    help_window = Window_Help.new
    case $game_map.n_turn
    when 1
      text = "1"
    when 2
      text = "2"
    when 3
      text = "3"
    when 4
      text = "4"
    when 5
      text = "5"
    when 6
      text = "6"
    when 7
      text = "7"
    when 8
      text = "8"
    when 9
      text = "9"
    else  
      text = sprintf("%2d", $game_map.n_turn)
    end
    text = "Turns: ("+text
    text += ")  End the party's turn?"
    help_window.set_text(text)
    ret = true
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Update command window
      command_window.update
      # If B Button was pressed
      if Input.trigger?(Input::B)
        ret = false
        break
      # If C button was pressed
      elsif Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        # Branch by command window current index
        case command_window.index
        when 1
          ret = false
          break
        when 0
          ret = true
          break
        end
      end
    end
    help_window.dispose
    command_window.dispose
    @simstatus_window.visible = true
    return ret
  end
end
 
 
 
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  This class performs menu screen processing.
#==============================================================================
 
class Scene_Menu
  #--------------------------------------------------------------------------
  # * Frame Update (when command window is active)
  #--------------------------------------------------------------------------
  def update_command
    # If B button was pressed
    if Input.trigger?(Input::B)
      # Play cancel SE
      $game_system.se_play($data_system.cancel_se)
      # Switch to map screen
      $scene = Scene_Map.new
      return
    end
    # If C button was pressed
    if Input.trigger?(Input::C)
      # If command other than save or end game, and party members = 0
      if $game_party.actors.size == 0 and @command_window.index < 4
        # Play buzzer SE
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # Branch by command window cursor position
      case @command_window.index
      when 0  # Item
        # Switch to map screen
        $scene = Scene_Map.new
        return
        xsave = $game_player.x
        ysave = $game_player.y
        Think(2)
        $game_player.moveto(xsave, ysave)
        for event in $game_map.events.values
          event.wait_time = 0
          event.step_anime = true
        end
      when 1  # Skill
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Make status window active
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 2  # equipment
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Make status window active
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 3  # status
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Make status window active
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 4  # save
        # If saving is forbidden
        if $game_system.save_disabled
          # Play buzzer SE
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to save screen
        $scene = Scene_Save.new
      when 5  # end game
        # Play decision SE
        $game_system.se_play($data_system.decision_se)
        # Switch to end game screen
        $scene = Scene_End.new
      end
      return
    end
  end
end
 
 
 
#==============================================================================
# ** Scene_SimBattle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================
 
class Scene_SimBattle
  #--------------------------------------------------------------------------
  # * 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
    @help_window = Window_Help.new
    @help_window.back_opacity = 160
    @help_window.visible = false
    @status_window = Window_SimBattleStatus.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 main phase
    start_phase4
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Frame update
      update
      # Abort loop if screen is changed
      break if $scene != self
    end    
    # Refresh map
    $game_map.refresh
    # Prepare for transition
    Graphics.freeze
    # Dispose of windows
    @help_window.dispose
    @status_window.dispose
    @message_window.dispose
    # Dispose of sprite set
    @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  
  #--------------------------------------------------------------------------
  # * Battle Ends
  #     result : results (0:win 1:lose 2:escape)
  #--------------------------------------------------------------------------
  def battle_end(result)
    # Clear in battle flag
    $game_temp.in_battle = false
    # Clear entire party actions flag
    $game_party.clear_actions
    # Remove battle states
    for actor in $game_party.actors
      actor.remove_states_battle
    end
    # Clear enemies
    $game_troop.enemies.clear
    # Call battle callback
    if $game_temp.battle_proc != nil
      $game_temp.battle_proc.call(result)
      $game_temp.battle_proc = nil
    end
    # Switch to map screen
    $scene = Scene_Map.new
  end  
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    # 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
    @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
    return if $game_temp.message_window_showing
    # If effect is showing
    return if @spriteset.effect?
    # If waiting
    if @wait_count > 0
      # Decrease wait count
      @wait_count -= 1
      return
    end
    # If battler forcing an action doesn't exist,
    # and battle event is running
    if $game_temp.forcing_battler == nil and
       $game_system.battle_interpreter.running?
      return
    end
    # Branch according to phase
    case @phase
    when 1  # pre-battle phase
      update_phase1
    when 2  # party command phase
      update_phase2
    when 3  # actor command phase
      update_phase3
    when 4  # main phase
      update_phase4
    when 5  # after battle phase
      update_phase5
    end
  end
  #--------------------------------------------------------------------------
  # * Start Main Phase
  #--------------------------------------------------------------------------
  def start_phase4
    # Shift to phase 4
    @phase = 4
    # Set actor as unselectable
    @actor_index = -1
    @active_battler = nil
    # Set main phase flag
    $game_temp.battle_main_phase = true
    # Make enemy action
    for enemy in $game_troop.enemies
      enemy.make_action
    end
    # Make action orders
    make_action_orders
    # Shift to step 1
    @phase4_step = 1
  end
  #--------------------------------------------------------------------------
  # * Make Action Orders
  #--------------------------------------------------------------------------
  def make_action_orders
    # Initialize @action_battlers array
    @action_battlers = []
    # Add actor to @action_battlers array
    @action_battlers.push($sim_enemy[0])
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase)
  #--------------------------------------------------------------------------
  def update_phase4
    case @phase4_step
    when 1
      update_phase4_step1
    when 2
      update_phase4_step2
    when 3
      update_phase4_step3
    when 4
      update_phase4_step4
    when 5
      update_phase4_step5
    when 6
      update_phase4_step6
    end
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 1 : action preparation)
  #--------------------------------------------------------------------------
  def update_phase4_step1
    # Hide help window
    @help_window.visible = false
    # If no actionless battlers exist (all have performed an action)
    if @action_battlers.size == 0
      # Start party command phase
      start_phase2
      return
    end
    # Initialize animation ID and common event ID
    @animation1_id = 0
    @animation2_id = 0
    @common_event_id = 0
    # Shift from head of actionless battlers
    @active_battler = @action_battlers.shift
    # If already removed from battle
    return if @active_battler.index == nil
    # Refresh status window
    @status_window.refresh
    # Shift to step 2
    @phase4_step = 2
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 2 : start action)
  #--------------------------------------------------------------------------
  def update_phase4_step2
    # Clear target battlers
    @target_battlers = []
    # Branch according to each action
    case @active_battler.current_action.kind
    when 0  # basic
      make_basic_action_result
    when 1  # skill
      make_skill_action_result
    when 2  # item
      make_item_action_result
    end
    $sim_enemy[1].hp = $sim_enemy[1].new_hp
    # Shift to step 3
    if @phase4_step == 2
      @phase4_step = 3
    end
  end
  #--------------------------------------------------------------------------
  # * Make Basic Action Results
  #--------------------------------------------------------------------------
  def make_basic_action_result
    # Set animation ID
    @animation1_id = @active_battler.animation1_id
    @animation2_id = @active_battler.animation2_id
    # Set the array of the tactical battler
    @target_battlers = [$sim_enemy[1]]
    return
  end
  #--------------------------------------------------------------------------
  # * Make Skill Action Results 
  #--------------------------------------------------------------------------
  def make_skill_action_result
    # Get skill
    @skill = $data_skills[@active_battler.current_action.skill_id]
    # Refresh status window
    @status_window.refresh
    # Show skill name on help window
    @help_window.set_text(@skill.name, 1)
    # Set animation ID
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    # Set the array of the tactical battler
    @target_battlers = [$sim_enemy[1]]
  end
  #--------------------------------------------------------------------------
  # * Make Item Action Results 
  #--------------------------------------------------------------------------
  def make_item_action_result
    # Get item
    @item = $data_items[@active_battler.current_action.item_id]
    # Display item name on help window
    @help_window.set_text(@item.name, 1)
    # Set animation ID
    @animation1_id = @item.animation1_id
    @animation2_id = @item.animation2_id
    # Set the array of the tactical battler
    @target_battlers = [$sim_enemy[1]]
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 3 : animation for action performer) 
  #--------------------------------------------------------------------------
  def update_phase4_step3
    # Animation for action performer (if ID is 0, then white flash)
    if @animation1_id == 0
      @active_battler.white_flash = true
    else
      @active_battler.animation_id = @animation1_id
      @active_battler.animation_hit = true
    end
    # Shift to step 4
    @phase4_step = 4
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 4 : animation for target) 
  #--------------------------------------------------------------------------
  def update_phase4_step4
    # Animation for target
    for target in @target_battlers
      target.animation_id = @animation2_id
      target.animation_hit = (target.damage != "Miss")
    end
    # Animation has at least 8 frames, regardless of its length
    @wait_count = 8
    # Shift to step 5
    @phase4_step = 5
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 5 : damage display)
  #--------------------------------------------------------------------------
  def update_phase4_step5
    # Hide help window
    @help_window.visible = false
    # Refresh status window
    @status_window.refresh
    # Display damage
    for target in @target_battlers
      if target.damage != nil
        target.damage_pop = true
      end
    end
    # Shift to step 6
    @phase4_step = 6
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 6 : refresh)
  #--------------------------------------------------------------------------
  def update_phase4_step6
    # Clear battler being forced into action
    $game_temp.forcing_battler = nil
    # If common event ID is valid
    if @common_event_id > 0
      # Set up event
      common_event = $data_common_events[@common_event_id]
      $game_system.battle_interpreter.setup(common_event.list, 0)
    end
    # Battle ends
    battle_end(0)
  end
end
 
 
 
#==============================================================================
# ** Scene_SimStatus
#------------------------------------------------------------------------------
#  This class performs status screen processing.
#==============================================================================
 
class Scene_SimStatus
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     actor_index : actor index
  #--------------------------------------------------------------------------
  def initialize(actor)
    @actor = actor
  end
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  def main
    # Make status window
    @status_window = Window_Status.new(@actor)
    # Main loop
    loop do
      # Update game screen
      Graphics.update
      # Update input information
      Input.update
      # Abort loop if B button was pressed
      break if Input.trigger?(Input::B)
    end
    # Dispose of windows
    @status_window.dispose
  end
end