modification de commande en combat

#==============================================================================
# Individual Battle Commands
# by Atoa
# Based on Charlie FLeed script
#==============================================================================
# This scripts allows you to make diferent commands for each actor
#
# Now you can not only add an command to an skill, you can also add an command
# to an actor (like in RM2000/2003/VX) and add an skill directly to an command
# so if you select the command, the skill will be used without opening the
# skill menu
#
# IMPORTANT: If you using the 'Atoa ATB' or 'Atoa CTB', put this script bellow them
#==============================================================================

module Atoa
  # Do not remove or change these lines
  Skill_Command = {}
  Actor_Command = {}
  Usable_Command = {}
  Command_Color = {}
  Custom_Command_Order = {}
  # Do not remove or change these lines

  # Skill Commands.
  # These commands appear automatically when an actor learn one of the skill
  # that is part of the command.
  #
  # Skill_Command[Command_Name] = [Skills_IDs]
  #
  Skill_Command['Magic'] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
    35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
    54, 55, 56]
 
  Skill_Command['Techs'] = [57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
    69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80]
 
  Skill_Command['Summon'] = [83,84,85,86]
 
  Skill_Command['Limit Break'] = [108]
 
  Skill_Command['Unite'] = [100,103]
   
  # Actor Commands.
  # These are the commands linked to the actors, they will be shown even if
  # the actor has none of the skill of this command.
  # You can add the same command for different actors, the list of skills shown
  # will be separated for each
  #
  # Actor_Command[Command_Name] = {Actor_id => [Skills_IDs]}
  #
  Actor_Command['Skill'] = {1 => [88,92,97], 2 => [89,93,99], 3 => [90,95,96,106]}
 
  Actor_Command['Wizzardry'] = {4 => [91,94,98,109,107]}
 
  # Usable Commands.
  # These commands are linked directly to an skill. Once you choose one of them
  # you will use without opening the skill menu.
  # This command appear automatically once the actor learn the skill linked to
  # the command. The skill linked to the command aren't shown in the skill
  # menu outside battle
  #
  # Direct_Comman[Command_Name] = Skill_ID
  #
  Usable_Command['Steal'] = 82
 
  Usable_Command['Return'] = 87
 
  # Commands Color
  # You can add different colors for each command name
  #  Command_Color[Command_Name] = [red, green, blue]
  Command_Color['Limit Break'] = [255, 255, 0]
 
  # Custom Command Order
  # You can change the order that the commands are shown for specific actors.
  # You must add *all* possible commands that the actor can have for skill commands.
  # They will be shown only if the actor fills the conditions for it.
  # Commands not listed here will be never shown for that actor, even if he fills the
  # condition to have that command. You can use that to remove basic commands
  # like "Attack" and "Defend" from an Actor.
  Custom_Command_Order[2] = ['Item','Attack','Defend','Magic','Techs','Skill','Summon']
 
  #==============================================================================
  # Window Settings
  #==============================================================================
 
  # Show command list in status menu?
  Show_Commands_In_Menu = false
 
  # Position of command window in status menu
  Menu_Commands_Postition = [16,160]
  # Note: you must edit the status menu, or the command window will stay above
  # other informations
   
  # Command Window Border Opacity
  Command_Window_Border_Opacity = 255
 
  # Command Window Back Opacity
  Command_Window_Back_Opacity = 160
 
  # Max number of commands shown
  Max_Commands_Shown = 5
 
  # Image filename for window backgeound, must be on the Windowskin folder
  Command_Window_Bg = ''
 
  # Position of the backgroun image
  # Command_Window_Bg_Postion = [Position X, Position Y]
  Command_Window_Bg_Position = [0, 0]
 
  #==============================================================================
  # OVEDRIVE COMMANDS
  #==============================================================================
  # This part only has effect if used toghter with the Skill Overdrive Script.
  # With it you can make commands that are only shown if the Overdrive bar is full
  # Just add the command name bellow. Remember that the command must be configurated
  # according the other options. You can add how many commands you want
  Overdtive_Commands = ['Limit Break']
 
end

#==============================================================================
# ■ Atoa Module
#==============================================================================
$atoa_script = {} if $atoa_script.nil?
$atoa_script['Atoa Individual Commands'] = true

#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor
  #--------------------------------------------------------------------------
  attr_accessor :individual_commands
  #--------------------------------------------------------------------------
  alias atoa_setup_ibc setup
  def setup(actor_id)
    atoa_setup_ibc(actor_id)
    @individual_commands = []
  end
  #--------------------------------------------------------------------------
  def refresh_commands
    @individual_commands = []
    for i in 0...@skills.size
      skill = $data_skills[@skills[i]]
      if skill != nil
        for command in Skill_Command.dup
          if command[1].include?(skill.id) and not @individual_commands.include?(command[0])
            next if $atoa_script['Atoa Overdrive'] and (Overdtive_Commands.include?(command[0]) and !self.overdrive_full?)
            @individual_commands << command[0]
          end
        end
        for command in Usable_Command.dup
          if command[1] == skill.id and not @individual_commands.include?(command[0])
            next if $atoa_script['Atoa Overdrive'] and (Overdtive_Commands.include?(command[0]) and !self.overdrive_full?)
            @individual_commands << command[0]
          end
        end       
      end
    end
    for command in Actor_Command.dup
      if command[1].include?(@actor_id) and not @individual_commands.include?(command[0])
        @individual_commands << command[0]
      end
    end
  end
end

#==============================================================================
# ■ Game_Party
#==============================================================================
class Game_Party
  #--------------------------------------------------------------------------
  alias atoa_add_actor_ibc add_actor
  #--------------------------------------------------------------------------
  def add_actor(actor_id)
    atoa_add_actor_ibc(actor_id)
    actor = $game_actors[actor_id]
    actor.refresh_commands
  end
end

#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  attr_accessor :escape_name
  #--------------------------------------------------------------------------
  alias atoa_phase3_setup_command_window_ibc phase3_setup_command_window
  def phase3_setup_command_window
    atoa_phase3_setup_command_window_ibc
    @active_battler.refresh_commands
    set_commands
    @actor_command_window.dispose
    @actor_command_window = Window_Command_IBC.new(160, @individual_commands, @active_battler)
    comand_size = (@individual_commands.size >= 5 ? 5 : @individual_commands.size)
    command_window_position
    @actor_command_window.y = @actor_command_window.y + 120 - 24 * comand_size
    @actor_command_window.back_opacity = Command_Window_Back_Opacity
    @actor_command_window.opacity = Command_Window_Border_Opacity
    @actor_command_window.z = 4500
    @actor_command_window.index = 0
    @actor_command_window.active = true
    @actor_command_window.visible = true
    @active_battler_window.refresh(@active_battler)
    @active_battler_window.visible = Battle_Name_Window
    set_name_window_position
  end
  #--------------------------------------------------------------------------
  def set_commands
    if Custom_Command_Order[@active_battler.id] != nil
      @individual_commands = []
      basic_commands = [$data_system.words.attack, $data_system.words.item, $data_system.words.guard]
      custom_commands = @active_battler.individual_commands.dup
      commands = Custom_Command_Order[@active_battler.id].dup
      for i in 0...commands.size
        @individual_commands << commands[i] if basic_commands.include?(commands[i])
        @individual_commands << commands[i] if custom_commands.include?(commands[i])
      end
      return
    end
    s1 = $data_system.words.attack
    s2 = $data_system.words.item
    s3 = $data_system.words.guard
    s4 = @escape_name if @escape_type == 0
    @individual_commands = [s1] + @active_battler.individual_commands + [s2, s3]
    if @escape_type == 0
      @individual_commands = [s1]+  @active_battler.individual_commands + [s2, s3, s4]
    end
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_basic_command_ibc update_phase3_basic_command
  def update_phase3_basic_command
    @direct_command = false
    if Input.trigger?(Input::C)
      @command_name = @actor_command_window.commands[@actor_command_window.index]
      case @command_name
      when @escape_name
        if $game_temp.battle_can_escape == false
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        update_phase2_escape
        return
      end
      if @active_battler != nil and
        @active_battler.individual_commands.include?(@command_name)
        if Usable_Command.include?(@command_name)
          unless @active_battler.skill_can_use?(Usable_Command[@command_name])
            $game_system.se_play($data_system.buzzer_se)
            return
          end
          @active_battler.current_action.kind = 1
          @commands_category = @command_name
          @direct_command = true
          start_command_select(Usable_Command[@command_name])
          return
        else
          $game_system.se_play($data_system.decision_se)
          @active_battler.current_action.kind = 1
          @commands_category = @command_name
          start_skill_select
          return
        end
      end
    end
    atoa_update_phase3_basic_command_ibc
  end
  #--------------------------------------------------------------------------
  alias atoa_start_skill_select_ibc start_skill_select
  def start_skill_select
    atoa_start_skill_select_ibc
    @skill_window.dispose
    @skill_window = Window_Skill.new(@active_battler, @commands_category)
    @skill_window.help_window = @help_window
  end
  #--------------------------------------------------------------------------
  def start_command_select(skill_id)
    if Input.trigger?(Input::C)
      @skill = $data_skills[skill_id]
      if @skill.nil? or not @active_battler.skill_can_use?(@skill.id)
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_system.se_play($data_system.decision_se)
      @active_battler.current_action.skill_id = @skill.id
      @skill_window.visible = false if @skill_window != nil
      ext = check_extension(@skill, 'TARGET')
      ext.slice!('TARGET/') unless ext.nil?
      if ext == 'ALLBATTLERS'
        start_select_all_battlers
        return
      elsif ext == 'ALLENEMIES' or @skill.scope == 2 or (@skill.scope == 1 and
        check_include(@skill, 'RANDOM'))
        start_select_all_enemies
        return
      elsif ext == 'ALLALLIES' or @skill.scope == 4 or (@skill.scope == 3 and
        check_include(@skill, 'RANDOM'))
        start_select_all_actors
        return
      end
      if @skill.scope == 1
        start_enemy_select
      elsif @skill.scope == 3 or @skill.scope == 5
        start_actor_select
      else
        phase3_next_actor
      end
      return
    end
  end
  #--------------------------------------------------------------------------
  def active_command_window
    @actor_command_window.active = true
    @actor_command_window.visible = true
    @help_window.visible = false
    @active_battler_window.visible = true if Battle_Name_Window
  end
  #--------------------------------------------------------------------------
  alias atoa_end_enemy_select_ibc end_enemy_select
  def end_enemy_select
    atoa_end_enemy_select_ibc
    if @actor_command_window.commands[@actor_command_window.index] == $data_system.words.attack
      @active_battler_window.visible = true
      @actor_command_window.active = true
      @actor_command_window.visible = true
      @help_window.visible = false
    end
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_enemy_select_ibc update_phase3_enemy_select
  def update_phase3_enemy_select
    if Input.trigger?(Input::B) and @direct_command
      $game_system.se_play($data_system.cancel_se)
      end_enemy_select
      active_command_window
      return
    end
    if Input.trigger?(Input::C) and @direct_command
      $game_system.se_play($data_system.decision_se)
      @active_battler.current_action.target_index = @enemy_arrow.index
      end_enemy_select
      phase3_next_actor
      @help_window.visible = false
      return
    end
    atoa_update_phase3_enemy_select_ibc
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_actor_select_ibc update_phase3_actor_select
  def update_phase3_actor_select
    if Input.trigger?(Input::B) and @direct_command
      $game_system.se_play($data_system.cancel_se)
      end_actor_select
      active_command_window
      return
    end
    if Input.trigger?(Input::C) and @direct_command
      $game_system.se_play($data_system.decision_se)
      @active_battler.current_action.target_index = @actor_arrow.index
      end_actor_select
      phase3_next_actor
      @help_window.visible = false
      return
    end
    atoa_update_phase3_actor_select_ibc
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_select_all_enemies_ibc update_phase3_select_all_enemies
  def update_phase3_select_all_enemies
    @enemy_arrow_all.update_multi_arrow
    if Input.trigger?(Input::B) and @direct_command
      $game_system.se_play($data_system.cancel_se)
      end_select_all_enemies
      active_command_window
      return
    end
    if Input.trigger?(Input::C) and @direct_command
      $game_system.se_play($data_system.decision_se)
      end_select_all_enemies
      phase3_next_actor
      @help_window.visible = false
      return
    end
    atoa_update_phase3_select_all_enemies_ibc
  end
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_select_all_actors_ibc update_phase3_select_all_actors
  def update_phase3_select_all_actors
    @actor_arrow_all.update_multi_arrow
    if Input.trigger?(Input::B) and @direct_command
      $game_system.se_play($data_system.cancel_se)
      end_select_all_actors
      active_command_window
      return
    end
    if Input.trigger?(Input::C) and @direct_command
      $game_system.se_play($data_system.decision_se)
      end_select_all_actors
      phase3_next_actor
      @help_window.visible = false
      return
    end
    atoa_update_phase3_select_all_actors_ibc
  end     
  #--------------------------------------------------------------------------
  alias atoa_update_phase3_select_all_battlers_ibc update_phase3_select_all_battlers
  def update_phase3_select_all_battlers
    @battler_arrow_all.update_multi_arrow
    if Input.trigger?(Input::B) and @direct_command
      $game_system.se_play($data_system.cancel_se)
      end_select_all_battlers
      active_command_window
      return
    end
    if Input.trigger?(Input::C) and @direct_command
      $game_system.se_play($data_system.decision_se)
      end_select_all_battlers
      phase3_next_actor
      @help_window.visible = false
      return
    end
    atoa_update_phase3_select_all_battlers_ibc
  end     
end

#==============================================================================
# ■ Window_Skill
#==============================================================================
class Window_Skill < Window_Selectable
  #--------------------------------------------------------------------------
  def initialize(actor, skill_command_type = '')
    super(0, 128, 640, 352)
    @skill_command_type = skill_command_type
    @actor = actor
    @column_max = 2
    refresh
    self.index = 0
    if $game_temp.in_battle
      self.y = 320
      self.height = 160
      self.z = 900
      self.back_opacity = Base_Opacity
    end
  end
  #--------------------------------------------------------------------------
  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    for i in 0...@actor.skills.size
      skill = $data_skills[@actor.skills[i]]
      if skill != nil and $game_temp.in_battle and skill_in_command?(skill)
        @data << skill
      elsif skill != nil and not $game_temp.in_battle
        for command in  Usable_Command.dup
          @data << skill unless command[1] == skill.id or @data.include?(skill)
        end
      end
    end
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      for i in 0...@item_max
        draw_item(i)
      end
    end
  end
  #--------------------------------------------------------------------------
  def skill_in_command?(skill)
    if Skill_Command[@skill_command_type] != nil and
      Skill_Command[@skill_command_type].include?(skill.id)
      return true
    elsif Actor_Command[@skill_command_type] != nil and
      Actor_Command[@skill_command_type].include?(@actor.id) and
      Actor_Command[@skill_command_type][@actor.id].include?(skill.id)
      return true
    end
    return false
  end
end

#==============================================================================
# ■ Window_Command_IBC
#==============================================================================
class Window_Command_IBC < Window_Selectable
  #--------------------------------------------------------------------------
  attr_accessor :commands
  #--------------------------------------------------------------------------
  def initialize(width, commands, battler = nil)
    if $game_temp.in_battle
      comand_size = (commands.size >= 5 ? 192 : commands.size * 32 + 32)
    else
      comand_size =  commands.size * 32 + 32
    end
    comand_size = [comand_size, Max_Commands_Shown * 32 + 32].min
    super(0, 0, width, comand_size)
    @battler = battler
    @item_max = commands.size
    @commands = commands
    self.contents = Bitmap.new(width - 32, @item_max * 32)
    refresh
    self.index = 0
    if Command_Window_Bg != nil
      @background_image = Sprite.new
      @background_image.bitmap = RPG::Cache.windowskin(Command_Window_Bg)
      @background_image.x = Command_Window_Bg_Position[0]
      @background_image.y = Command_Window_Bg_Position[1]
      @background_image.z = 4499
    end
  end
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    for i in 0...@item_max
      if $game_temp.in_battle and @battler != nil and
        Usable_Command.include?(@commands[i]) and not
        @battler.skill_can_use?(Usable_Command[@commands[i]])
        draw_item(i, disabled_color)
      elsif $game_temp.in_battle and @commands[i] == $scene.escape_name and
        $game_temp.battle_can_escape == false
        draw_item(i, disabled_color)
      else
        draw_item(i, normal_color)
      end
    end
  end
  #--------------------------------------------------------------------------
  def draw_item(index, color)
    self.contents.font.color = set_font_color(index, color)
    rect = Rect.new(4, 32 * index, self.contents.width - 8, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.draw_text(rect, @commands[index])
  end
  #--------------------------------------------------------------------------
  def set_font_color(index, color)
    return color if Command_Color[@commands[index]].nil?
    c = Command_Color[@commands[index]].dup
    return Color.new(c[0],c[1],c[2])
  end
  #--------------------------------------------------------------------------
  def commands_size
    return @item_max
  end
end

#==============================================================================
# ■ Scene_Status
#==============================================================================
class Scene_Status
  #--------------------------------------------------------------------------
  include Atoa
  #--------------------------------------------------------------------------
  alias atoa_main_scenestatus_ibc main
  def main
    set_command_window if Show_Commands_In_Menu
    atoa_main_scenestatus_ibc
    @command_window.dispose if Show_Commands_In_Menu
  end
  #--------------------------------------------------------------------------
  def set_command_window
    actor = $game_party.actors[@actor_index]
    actor.refresh_commands
    if ($atoa_script['Atoa ATB'] and Escape_Type == 0) or $atoa_script['Atoa CTB']
      @escape_type = 0
    end
    set_commands
    @command_window = Window_Command_IBC.new(160, @individual_commands, actor)
    @command_window.x = Menu_Commands_Postition[0]
    @command_window.y = Menu_Commands_Postition[1]
    @command_window.z = 1000
    @command_window.active = false
    @command_window.index = -1
  end
  #--------------------------------------------------------------------------
  def set_commands
    actor = $game_party.actors[@actor_index]
    if Custom_Command_Order[actor.id] != nil
      @individual_commands = []
      basic_commands = [$data_system.words.attack, $data_system.words.item, $data_system.words.guard]
      custom_commands = actor.individual_commands.dup
      commands = Custom_Command_Order[actor.id].dup
      for i in 0...commands.size
        @individual_commands << commands[i] if basic_commands.include?(commands[i])
        @individual_commands << commands[i] if custom_commands.include?(commands[i])
      end
      return
    end
    s1 = $data_system.words.attack
    s2 = $data_system.words.item
    s3 = $data_system.words.guard
    s4 = @escape_name if @escape_type == 0
    @individual_commands = [s1] + actor.individual_commands + [s2, s3]
    if @escape_type == 0
      @individual_commands = [s1]+  actor.individual_commands + [s2, s3, s4]
    end
  end
end