#==============================================================================
# �¡ VXAce-RGSS3-40 ƒRƒ}ƒ“ƒhƒXƒLƒ‹ [data]        by Claimh
#==============================================================================

module CmdBtl
  #--------------------------------------------------------------------------
  # �œ ƒRƒ}ƒ“ƒhƒŠƒZƒbƒg
  #--------------------------------------------------------------------------
  def self.reset_on_action; SLOT_TYPE == 0; end
  def self.reset_on_battle; [0, 1].include?(SLOT_TYPE); end
  def self.slot_is_tp;      SLOT_TYPE == 3; end
  #--------------------------------------------------------------------------
  # �œ ƒf�[ƒ^
  #--------------------------------------------------------------------------
  def self.data(d, id)
    d[id].nil? ? d[0] : d[id]
  end
  #--------------------------------------------------------------------------
  # �œ ƒRƒ}ƒ“ƒh
  #--------------------------------------------------------------------------
  def self.commands(actor)
    data(CMD, actor.id)
  end
  #--------------------------------------------------------------------------
  # �œ ƒRƒ}ƒ“ƒh
  #--------------------------------------------------------------------------
  def self.fin; Input.trigger?(:B);     end
  def self.up;  Input.trigger?(:UP);    end
  def self.dw;  Input.trigger?(:DOWN);  end
  def self.rt;  Input.trigger?(:RIGHT); end
  def self.lf;  Input.trigger?(:LEFT);  end
  def self.r;   Input.press?(:R);       end
  def self.ru;  r and up; end
  def self.rd;  r and dw; end
  def self.rr;  r and rt; end
  def self.rl;  r and lf; end
  def self.trigger_methods
    [method(:up), method(:dw), method(:rt), method(:lf),
     method(:ru), method(:rd), method(:rr), method(:rl)]
  end
  def self.trigger?(i)
    trigger_methods[i].call
  end
  #--------------------------------------------------------------------------
  # �œ ƒRƒ}ƒ“ƒhKeys
  #--------------------------------------------------------------------------
  def self.trigger_cmd(actor)
    commands(actor).each_with_index {|s, i| return s if !s.nil? and trigger?(i) }
    nil
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒhKeys
  #--------------------------------------------------------------------------
  def self.trigger_atk_cmd
    return :finish if fin
    ATK.keys.each {|s| return s if Input.trigger?(ATK[s][0]) }
    nil
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒhƒL�[”z—ñ
  #--------------------------------------------------------------------------
  def self.atk_keys
    ATK.values.collect {|v| v[0]}
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒhƒL�[ => symbol
  #--------------------------------------------------------------------------
  def self.atk_symbol(key)
    ATK.keys.select {|k| ATK[k][0] == key}[0]
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒhƒXƒLƒ‹
  #--------------------------------------------------------------------------
  def self.attack(c, data=true)
    data ? $data_skills[ATK[c][1]] : ATK[c][1]
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒh‚Ì�Á”ïƒXƒ�ƒbƒg
  #--------------------------------------------------------------------------
  def self.atk_slot(c)
    ATK[c][2]
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒh‚ÌSE
  #--------------------------------------------------------------------------
  def self.play_atk_se(c)
    ATK[c][3].play
  end
  #--------------------------------------------------------------------------
  # �œ ƒXƒLƒ‹
  #--------------------------------------------------------------------------
  def self.skill(actor)
    data(SKILL, actor.id)
  end
  def self.skill_ids(actor)
    skill(actor).keys
  end
  #--------------------------------------------------------------------------
  # �œ ƒXƒLƒ‹Žg—p‰Â”Û”»’è
  #--------------------------------------------------------------------------
  def self.usable?(actor, skill, used)
    return false unless actor.usable?(skill)
    return false if slot_is_tp and (actor.tp - used) < actor.skill_tp_cost(skill)
    true
  end
  #--------------------------------------------------------------------------
  # �œ ƒXƒLƒ‹
  #--------------------------------------------------------------------------
  def self.usable_skill(actor, used, predict=false)
    hash = skill(actor)
    skills = []
    hash.each_key do |key|
      skill = $data_skills[key]
      enable = usable?(actor, skill, used)
      skills.push([skill, hash[key], enable]) if predict or enable
    end
    skills
  end
end

#==============================================================================
# �¡ ActorAtkCmd  : �UŒ‚ƒRƒ}ƒ“ƒhƒNƒ‰ƒX
#==============================================================================
class ActorAtkCmd
  MAX_CMD = 3   # �Å‘åƒRƒ}ƒ“ƒh�”
  #--------------------------------------------------------------------------
  # �œ ƒIƒuƒWƒFƒNƒg�‰Šú‰»
  #--------------------------------------------------------------------------
  def initialize(id)
    @id = id
    actor.refresh_slot
    @slot = CmdBtl.slot_is_tp ? actor.tp.to_i : actor.cmd_slot
    clear
  end
  #--------------------------------------------------------------------------
  # �œ Žg—pƒXƒ�ƒbƒgƒNƒŠƒA
  #--------------------------------------------------------------------------
  def clear
    @used = 0
    @cmd = []
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚‰ñ�”
  #--------------------------------------------------------------------------
  def size
    @cmd.size + (fitted_skill.nil? ? 0 : 1)
  end
  #--------------------------------------------------------------------------
  # �œ ŽcƒXƒ�ƒbƒg
  #--------------------------------------------------------------------------
  def remain
    @slot - @used
  end
  #--------------------------------------------------------------------------
  # �œ ƒAƒNƒ^�[ŽQ�Æ
  #--------------------------------------------------------------------------
  def actor
    $game_actors[@id]
  end
  #--------------------------------------------------------------------------
  # �œ Žg—p‰Â”\ƒRƒ}ƒ“ƒh
  #--------------------------------------------------------------------------
  def useable_atk_keys
    CmdBtl.atk_keys.select {|k| attackable?(CmdBtl.atk_symbol(k))}
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒh‘I‘ð‰Â”\�H
  #--------------------------------------------------------------------------
  def attackable?(c)
    return false unless CmdBtl.usable?(actor, CmdBtl.attack(c), @used)
    (remain - CmdBtl.atk_slot(c)) >= 0
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒRƒ}ƒ“ƒhPush
  #--------------------------------------------------------------------------
  def push(c)
    if attackable?(c)
      @used += CmdBtl.atk_slot(c)
      @cmd.push(c)
    end
  end
  #--------------------------------------------------------------------------
  # �œ ƒRƒ}ƒ“ƒh�ãŒÀ�H
  #--------------------------------------------------------------------------
  def full?
    return true if @cmd.size == MAX_CMD
    return true unless fitted_skill.nil?
    CmdBtl::ATK.keys.all? {|c| remain < CmdBtl.atk_slot(c)}
  end
  #--------------------------------------------------------------------------
  # �œ ƒXƒLƒ‹—\‘ª
  #--------------------------------------------------------------------------
  def predict_skill
    return [] if @cmd.empty?
    CmdBtl.usable_skill(actor, @used, true).select {|s| @cmd == s[1][0, @cmd.size]}.collect {|s| [s[0], s[1][@cmd.size], s[2]]}
  end
  #--------------------------------------------------------------------------
  # �œ ”­“®ƒXƒLƒ‹�Ý’è
  #--------------------------------------------------------------------------
  def fitted_skill
    return nil if @cmd.empty?
    CmdBtl.usable_skill(actor, @used).select {|s| @cmd == s[1]}.collect {|s| s[0]}[0]
  end
  #--------------------------------------------------------------------------
  # �œ Actionƒf�[ƒ^�¶�¬
  #--------------------------------------------------------------------------
  def attack_action(c, index)
    action = Game_Action.new(actor)
    action.set_skill( CmdBtl.attack(c, false) )
    action.target_index = index
    action
  end
  def skill_action(index)
    CmdBtl::SKILL_SE.play
    action = Game_Action.new(actor)
    action.set_skill( fitted_skill.id )
    action.target_index = index
    action
  end
  #--------------------------------------------------------------------------
  # �œ Actionƒf�[ƒ^“o˜^
  #--------------------------------------------------------------------------
  def finish
    actions = @cmd.collect {|c| attack_action(c, actor.current_action.target_index)}
    actions.push(skill_action(actor.current_action.target_index)) unless fitted_skill.nil?
    actor.set_atkcmd(actions)
    CmdBtl.slot_is_tp ? (actor.tp -= @slot) : (actor.cmd_slot = remain)
  end
end



#==============================================================================
# �¡ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
  #--------------------------------------------------------------------------
  # �œ �퓬�s“®‚Ì�ì�¬ [AtkCmd]
  #--------------------------------------------------------------------------
  def set_atkcmd(acts)
    remove_current_action
    @actions = acts + @actions
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒXƒ�ƒbƒg‚̃ŠƒZƒbƒg
  #--------------------------------------------------------------------------
  def reset_cmt_slot
  end
  #--------------------------------------------------------------------------
  # �œ �퓬ŠJŽn�ˆ—�
  #--------------------------------------------------------------------------
  alias on_battle_start_cmdbtl on_battle_start
  def on_battle_start
    on_battle_start_cmdbtl
    reset_cmt_slot if CmdBtl.reset_on_battle
  end
  #--------------------------------------------------------------------------
  # �œ �퓬�s“®�I—¹Žž‚Ì�ˆ—�
  #--------------------------------------------------------------------------
  alias on_action_end_cmdbtl on_action_end
  def on_action_end
    on_action_end_cmdbtl
    reset_cmt_slot if CmdBtl.reset_on_action
  end
  #--------------------------------------------------------------------------
  # �œ �퓬�I—¹�ˆ—�
  #--------------------------------------------------------------------------
  alias on_battle_end_cmdbtl on_battle_end
  def on_battle_end
    on_battle_end_cmdbtl
    reset_cmt_slot if CmdBtl.reset_on_battle
  end
end

#==============================================================================
# �¡ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # �œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï�”
  #--------------------------------------------------------------------------
  attr_accessor :cmd_slot             # ŽcƒXƒ�ƒbƒg�”
  #--------------------------------------------------------------------------
  # �œ ƒZƒbƒgƒAƒbƒv
  #--------------------------------------------------------------------------
  alias setup_cmdbtl setup
  def setup(actor_id)
    setup_cmdbtl(actor_id)
    reset_cmt_slot
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒXƒ�ƒbƒg‚̃ŠƒZƒbƒg
  #--------------------------------------------------------------------------
  def reset_cmt_slot
    @cmd_slot = 0
  end
  #--------------------------------------------------------------------------
  # �œ �UŒ‚ƒXƒ�ƒbƒg‚̉ñ•œ
  #--------------------------------------------------------------------------
  def refresh_slot
    @cmd_slot += CmdBtl.slot(self) unless CmdBtl.slot_is_tp
  end
end