Compétence voler

#=============================================================================
# ** Voler
#=============================================================================
# Auteur : Trickster
# Version 3 Final
# Modifié et édité par Saga_fire
#=============================================================================
=begin
Avant tout chose, allez dans base de donnée, système, attributs :
Créez un nouvel attribut a l'emplacement 17(si vous désirez un autre emplacement, allez
aux lignes 168 et 560 et modifiez la constante STEALING_ELEMENT_ID par
l'emplacement que vous désirez.

Ensuite toujours dans base de donnée, compétence :
Créez une nouvelle compétence et cochez l'attribut crée précédement

Les informations ci-dessous ne sont exactes que si le monstre dans base donnée a la
résistance a l'attribut précédement crée C (il est fortement recommendé de ne pas la mettre
au dessous de D)
Dans base de donnée, compétence,  intelligence :
Si intelligence = 1 vole une somme égale a  l'argent du monstre si variance = 0 ou une
                                  somme entre 0 et la somme égale a celle du monstre si variance = 100
Si intelligence = 2 vole un objet 4 types d'objets :
                Si esquive (au dessus s'intelligence) = 1, vole 1 objet, si equive = 2, vole 2 objets...
                                  un objet rare que l'on choisi plus bas
                                  un second objet que l'on choisi aussi plus bas
                                  un objet pareil que celui du monstre(si il en a un)
                                  un objet que le monstre nous a volé
Si intelligence = 3 même principe que  intelligence = 1 mais pour l'expérience
Si intelligence = 4 vole une compétence que l'on attribut a l'ennemi plus bas
Si intelligence = 5 vole une somme d'argent en fonction de certains facteur :
              Chez l'allié :
              défense et agilitée augemtent l'argent reçu,
              défense magique diminue l'argent reçu,
              variance fait varier l'argent reçu.
              Chez l'ennemi :
              défense et agilitée augemtent l'argent reçu, d
              éfense magique diminue l'argent reçu,
              variance fait varier l'argent reçu.
Si intelligence = 6 même principe que intelligence = 5 mais pour l'expérience

Aux lignes 86 et 87:
    when 1, le 1 signifie le premier monstre de la base de donnée (le fantome par défault)
    item_id représente  l'emplacement de  item_type volé de la base de donnée (1 étant
      la potion par défault pour les objets, l'épée de bronze pour les armes ou le bouclier de
      bronze pour les armures)
    si item_type = 1 ; on vole un objet, si  item_type = 2 ; on vole une arme et
      si item_type = 3 ; on vole une armure (bouclier, casque, armure et accessoire)
    chance est tout bètement le pourcentage de chance de voler l'item_id en question
Si vous voulez donner un second objet et/ou un objet rare a un monstre, il suffit de rajouter
dans get_item_ids(l.83) et/ou get_rare_ids(l.96) au dessous de retour un autre when avec
l'indentité du monstre et un return avec les valeur souhaitées dans le tableau. Ex :
when 4
  return [25, 2, 25]
Cela signifie que l'on volera au monstre 4, l'objet 25 de l'onglet armures avec 25% de chance

Pour donner une compétence a un monstre, allez dans get_skill_ids(l.109) et faite
la même chose sauf qu'il n'y a pas d'item_type
=end
#=============================================================================

#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
#  This class handles enemies. It's used within the Game_Troop class
#  ($game_troop).
#==============================================================================

class Game_Enemy
 
  attr_accessor :second_item_ids #the enemies second stealable item
  attr_accessor :rare_item_ids #the enemies rare item
  attr_accessor :ennemy_skill_ids #la compétence volé
 
  alias trickster_enemy_initialize initialize
  def initialize(troop_id, member_index)
    trickster_enemy_initialize(troop_id, member_index)
    @second_item_ids = get_item_ids
    @rare_item_ids = get_rare_ids
    @ennemy_skill_ids = get_skill_ids
  end
 
  def get_item_ids
    if self.is_a?(Game_Enemy)
      case self.id
      when 1
        return [1, 1, 100] #[item_id, item_type, chance]
      when 2
        return [2, 1, 100]
      when 3
        return [3, 3, 0]
      end
    end
  end
 
  def get_rare_ids
    if self.is_a?(Game_Enemy)
      case self.id
      when 1
        return [2, 1, 100] #[item_id, item_type, chance]
      when 2
        return [4, 3, 0]
      else
        return
      end
    end
  end
 
  def get_skill_ids
    if self.is_a?(Game_Enemy)
      case self.id
      when 1
        return [27, 100] #[skill_id, chance]
      when 3
        return [4, 0]
      else
        return
      end
    end
  end
end

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles the actor. It's used within the Game_Actors class
#  ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================

class Game_Actor
 
  attr_accessor :skills_lost #skill ids that were stolen
  attr_accessor :skills_gained #skill ids that were gained
 
  alias trickster_actor_initialize initialize
  def initialize(actor_id)
    @skills_lost = []
    @skills_gained = []
    trickster_actor_initialize(actor_id)
  end
end

#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
#  This class deals with battlers. It's used as a superclass for the Game_Actor
#  and Game_Enemy classes.
#==============================================================================

class Game_Battler
 
  DEXERITY_INFLUENCE = 100
  INTELLIGENCE_INFLUENCE = 100
  AGILITY_INFLUENCE = 67
  SKILL_DEFENSE_INT = 100
  SKILL_DEFENSE_DEX = 200
  SKILL_DEFENSE_AGI = 133
  FAILED_MESSAGE = 'Raté'
  NO_SKILLS_MESSAGE = 'Pas de magie'
  NO_ITEMS_MESSAGE = "Pas d'objet"
  STEAL_GOLD_ENEMY_GOLD = 1
  STEAL_ITEM_ENEMY_ITEM = 2
  STEAL_EXP_ENEMY_EXP = 3
  STEAL_SKILL = 4
  STEAL_GOLD_SKILL_POWER = 5
  STEAL_EXP_DEFINED_SKILL = 6
  MAX_RATING = 10
  STEALING_ELEMENT_ID = 17
 
  attr_accessor :stolen_gold #true if stolen gold from enemy
  attr_accessor :stolen_item #true if stolen item from enemy
  attr_accessor :stolen_skill #true if stolen skill from enemy
  attr_accessor :stolen_exp #true if stolen exp from enemy
  attr_accessor :stolen_rare #true if stolen rare item from enemy
  attr_accessor :gold_holding #= gold stolen if enemy stole from player
  attr_accessor :item_holding #= item id if enemy stole item from player
  attr_accessor :unstealable #items that aren't able to be stolen
 
  alias trickster_steal_initialize initialize
  def initialize
    trickster_steal_initialize
    @stolen_gold = false
    @stolen_item = false
    @stolen_skill = false
    @stolen_exp = false
    @stolen_rare = false
    @steal_normal_chance = true
    @gold_holding = 0
    @item_holding = []
    item_ids = []
    weapon_ids = []
    armor_ids = []
    @unstealable = [item_ids,weapon_ids,armor_ids]
  end

def steal_effect(attacker, skill, steal)
    #reset flags
    self.damage = 0
    self.critical = false
    #call get_chance to get hit result
    hit_result = get_chance(attacker, skill)
    if hit_result == true
      #Determine what are we stealing
      case steal
      when STEAL_GOLD_ENEMY_GOLD
        unless self.stolen_gold
          self.stolen_gold = true
          self.is_a?(Game_Enemy) ? power = self.gold : power = skill.power
          self.damage = power * elements_correct(skill.element_set)
          self.damage /= 100
          if skill.variance > 0 and self.damage.abs > 0
            amp = [self.damage.abs * skill.variance / 100, 1].max
            self.damage = (self.damage + rand(amp+1) + rand(amp+1) - amp) / 2
          end
          if self.gold_holding != 0
            self.damage = self.gold_holding
            self.gold_holding = 0
          end
          if self.is_a?(Game_Actor)
            $game_party.lose_gold(self.damage)
            attacker.gold_holding += self.damage
          else
            $game_party.gain_gold(self.damage)
          end
          attacker.stolen_gold = false
          self.damage = self.damage.to_s + ' ' + $data_system.words.gold
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        else
          self.damage = FAILED_MESSAGE
        end
      when STEAL_ITEM_ENEMY_ITEM #steal item
        if self.is_a?(Game_Enemy)
          number = skill.eva_f.to_s
          #Determine what type of item is stolen
          if self.rare_item_ids != nil and self.rare_item_ids[2] > rand(100)
            rare_id = self.rare_item_ids
            case rare_id[1]
            when 1
              $game_party.gain_item(rare_id[0],skill.eva_f)
              self.damage = number + ' ' +$data_items[rare_id[0]].name
              self.rare_item_ids = nil
            when 2
              $game_party.gain_weapon(rare_id[0],skill.eva_f)
              self.damage = number + ' ' +$data_weapons[rare_id[0]].name
              self.rare_item_ids = nil
            when 3
              $game_party.gain_armor(rare_id[0],skill.eva_f)
              self.damage = number + ' ' +$data_armors[rare_id[0]].name
              self.rare_item_ids = nil
            end
          elsif self.second_item_ids != nil and self.second_item_ids[2] > rand(100)
            sec_id = self.second_item_ids
            case sec_id[1]
            when 1
              $game_party.gain_item(sec_id[0],skill.eva_f)
              self.damage = number + ' ' +$data_items[sec_id[0]].name
              self.second_item_ids = nil
            when 2
              $game_party.gain_weapon(sec_id[0],skill.eva_f)
              self.damage = number + ' ' +$data_weapons[sec_id[0]].name
              self.second_item_ids = nil
            when 3
              $game_party.gain_armor(sec_id[0],skill.eva_f)
              self.damage = number + ' ' +$data_armors[sec_id[0]].name
              self.second_item_ids = nil
            end
          elsif steal_normal_chance and @steal_normal_chance == true
            if self.weapon_id != 0
              $game_party.gain_weapon(self.weapon_id, skill.eva_f)
              self.damage = number + ' ' +$data_weapons[self.weapon_id].name
            elsif self.armor_id != 0
              $game_party.gain_armor(self.armor_id, skill.eva_f)
              self.damage = number + ' ' +$data_armors[self.armor_id].name
            elsif self.item_id != 0
              $game_party.gain_item(self.item_id, skill.eva_f)
              self.damage = number + ' ' +$data_items[self.item_id].name
              @steal_normal_chance = false
            end
          elsif self.item_holding != []
            item = self.item_holding
            case item[1]
            when 1
              $game_party.gain_item(item[0],1)
              self.damage = number + ' ' +$data_items[item[0]].name
              self.objet = self.objet - 1
            when 2
              $game_party.gain_weapon(item[0],skill.eva_f)
              self.damage = number + ' ' +$data_weapons[item[0]].name
            when 3
              $game_party.gain_armor(item[0],skill.eva_f)
              self.damage = number + ' ' +$data_armors[item[0]].name
            end
            self.item_holding = []
          else
            if self.rare_item_ids == nil and self.second_item_ids == nil and
              @steal_normal_chance == false and self.item_holding == []
              self.damage = NO_ITEMS_MESSAGE
            elsif self.second_item_ids == nil and @steal_normal_chance == false and
              self.item_holding == []
              self.damage = NO_ITEMS_MESSAGE
            elsif @steal_normal_chance == false and self.item_holding == []
              self.damage = NO_ITEMS_MESSAGE
            else
              self.damage = FAILED_MESSAGE
            end
            return
          end
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        end
        if self.is_a?(Game_Actor)
          #enemy attempt to steal item
          #determine item type
          what_to_steal = rand(3)
          data = []
          #run through all avialable items
          case what_to_steal
          when 1
            for i in 1...$data_items.size
              if $game_party.item_number(i) > 0
                data.push($data_items[i])
              end
            end
          when 2
            for i in 1...$data_weapons.size
              if $game_party.weapon_number(i) > 0
                data.push($data_weapons[i])
              end
            end
          when 3
            for i in 1...$data_armors.size
              if $game_party.armor_number(i) > 0
                data.push($data_armors[i])
              end
            end
          end
          if data.size == 0
            self.damage = FAILED_MESSAGE
            return
          end
          #get a random item from list
          stolen_id = rand(data.size - 1)
          flag = false
          #if the item is unstealable it fails
          for i in 0...@unstealable[what_to_steal].size
            if @unstealable[what_to_steal][i] = data[stolen_id].id
              flag = true
            end
          end
          #check if the item is equippable and if it is currently equipped
          if what_to_steal > 1
            for actor in $game_party.actors
              if what_to_steal == 2
                if actor.weapon_id == data[stolen_id].id
                  flag = true
                end
              else
                if (actor.armor1_id == data[stolen_id].id or
                  actor.armor2_id == data[stolen_id].id or
                  actor.armor3_id == data[stolen_id].id or
                  actor.armor4_id == data[stolen_id].id)
                  flag = true
                end
              end
            end
          end
          #if the item was equipped steal fails
          if data.size == 1 and flag
            self.damage = FAILED_MESSAGE
            return
          end
          #checking again
          terminate = 0
          while flag
            terminate += 1
            stolen_id = rand(data.size - 1)
            flag = false
            for i in 0...@unstealable[what_to_steal].size
              if @unstealable[what_to_steal][i] = data[stolen_id].id
                flag = true
              end
            end
            if what_to_steal > 1
              for actor in $game_party.actors
                if what_to_steal == 2
                  if actor.weapon_id == data[stolen_id].id
                    flag = true
                  end
                else
                  if (actor.armor1_id == data[stolen_id].id or
                    actor.armor2_id == data[stolen_id].id or
                    actor.armor3_id == data[stolen_id].id or
                    actor.armor4_id == data[stolen_id].id)
                    flag = true
                  end
                end
              end
            end
            if terminate == 10 * data.size
              self.damage = FAILED_MESSAGE
              return
            end
          end
          #steal the item
          item_id = data[stolen_id].id
          case what_to_steal
          when 1
            $game_party.lose_item(item_id,1)
            self.damage = $data_items[item_id].name + ' Volé'
          when 2
            $game_party.lose_weapon(item_id,1)
            self.damage = $data_weapons[item_id.id].name + ' Volé'
          when 3
            $game_party.lose_armor(item_id,1)
            self.damage = $data_armors[item_id].name + ' Volé'
          end
          attacker.item_holding = [item_id, what_to_steal]
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        end
        when STEAL_EXP_ENEMY_EXP
        unless self.stolen_exp
          self.stolen_exp = true
          self.is_a?(Game_Enemy) ? power = self.exp : power = skill.power
          self.damage = power * elements_correct(skill.element_set)
          self.damage /= 100
          if skill.variance > 0 and self.damage.abs > 0
            amp = [self.damage.abs * skill.variance / 100, 1].max
            self.damage = (self.damage + rand(amp+1) + rand(amp+1) - amp) / 2
          end
          if self.is_a?(Game_Actor)
            self.exp -= self.damage
          else
            attacker.exp += self.damage
          end
          attacker.stolen_exp = false
          self.damage = self.damage.to_s + ' Exp'
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        else
          self.damage = FAILED_MESSAGE
        end
      when STEAL_SKILL
        if self.is_a?(Game_Enemy)
          #Determine what type of item is stolen
          if self.ennemy_skill_ids != nil and self.ennemy_skill_ids[1] > rand(100)
            skill_id = self.ennemy_skill_ids
            self.damage = $data_skills[skill_id[0]].name
            attacker.learn_skill(skill_id[0])
            self.ennemy_skill_ids = nil
          else
            if self.ennemy_skill_ids == nil
              self.damage = NO_SKILLS_MESSAGE
            else
              self.damage = FAILED_MESSAGE
            end
            return
          end
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        end
      when STEAL_GOLD_SKILL_POWER
        unless self.stolen_gold
          self.stolen_gold = true
          power = skill.power
          power += attacker.dex * skill.dex_f / DEXERITY_INFLUENCE
          power += attacker.int / self.int * INTELLIGENCE_INFLUENCE
          power += attacker.agi * skill.agi_f / AGILITY_INFLUENCE
          if power > 0
            power -= self.int * skill.mdef_f / SKILL_DEFENSE_INT
            power -= self.dex * skill.mdef_f / SKILL_DEFENSE_DEX
            power -= self.agi * skill.mdef_f / SKILL_DEFENSE_AGI
            power = [power, 0].max
          end
          self.damage = power * elements_correct(skill.element_set)
          self.damage /= 100
          if skill.variance > 0 and self.damage.abs > 0
            amp = [self.damage.abs * skill.variance / 100, 1].max
            self.damage += rand(amp+1) + rand(amp+1) - amp
          end
          if self.gold_holding != 0
            self.damage = self.gold_holding
            self.gold_holding = 0
          end
          if self.is_a?(Game_Actor)
            $game_party.lose_gold(self.damage)
            attacker.gold_holding += self.damage
          else
            $game_party.gain_gold(self.damage)
          end
          attacker.stolen_gold = false
          self.damage = self.damage.to_s + ' ' + $data_system.words.gold
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        else
          self.damage = FAILED_MESSAGE
        end
      when STEAL_EXP_DEFINED_SKILL
        unless self.stolen_exp
          self.stolen_exp = true
          power = skill.power
          power += attacker.dex * skill.dex_f / DEXERITY_INFLUENCE
          power += attacker.int / self.int * INTELLIGENCE_INFLUENCE
          power += attacker.agi * skill.agi_f / AGILITY_INFLUENCE
          if power > 0
            power -= self.int * skill.mdef_f / SKILL_DEFENSE_INT
            power -= self.dex * skill.mdef_f / SKILL_DEFENSE_DEX
            power -= self.agi * skill.mdef_f / SKILL_DEFENSE_AGI
            power = [power, 0].max
          end
          self.damage = power * elements_correct(skill.element_set)
          self.damage /= 100
          if skill.variance > 0 and self.damage.abs > 0
            amp = [self.damage.abs * skill.variance / 100, 1].max
            self.damage += rand(amp+1) + rand(amp+1) - amp
          end
          if self.is_a?(Game_Actor)
            self.exp -= self.damage
          else
            attacker.exp += self.damage
          end
          attacker.stolen_exp = false
          self.damage = self.damage.to_s + ' Exp'
          states_plus(skill.plus_state_set)
          states_minus(skill.minus_state_set)
        else
          self.damage = FAILED_MESSAGE
        end
      end
    else
      self.damage = FAILED_MESSAGE
    end
    return true
  end
 
  def get_chance(attacker, skill)
    int_inf =  self.int / attacker.int
    base_inf = self.agi / attacker.dex
    hit_inf = (100 - skill.hit)
    chance = rand(100) > (base_inf * int_inf * hit_inf)
    return chance
  end
 
  def steal_normal_chance
    self.rare_item_ids == nil ? rare = 0 : rare = self.rare_item_ids[2]
    self.second_item_ids == nil ? sec = 0 : sec = self.second_item_ids[2]
    return (100 - (rare+sec) > rand(100))
  end
end

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle
 
  STEALING_ELEMENT_ID = 17
 
  alias trickster_main main
  def main
    for actor in $game_party.actors
      actor.stolen_gold = false
      actor.stolen_item = false
      actor.stolen_skill = false
      actor.stolen_exp = false
    end
    trickster_main
  end
 
  def make_skill_action_result
    @skill = $data_skills[@active_battler.current_action.skill_id]
    unless @active_battler.current_action.forcing
      unless @active_battler.skill_can_use?(@skill.id)
        $game_temp.forcing_battler = nil
        @phase4_step = 1
        return
      end
    end
    @active_battler.sp -= @skill.sp_cost
    @status_window.refresh
    @help_window.set_text(@skill.name, 1)
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    @common_event_id = @skill.common_event_id
    set_target_battlers(@skill.scope)
    if @skill.element_set.include?(STEALING_ELEMENT_ID)
      for target in @target_battlers
        target.steal_effect(@active_battler, @skill, @skill.int_f)
      end
    else
      for target in @target_battlers
        target.skill_effect(@active_battler, @skill)
      end
    end
  end
 
  alias trickster_battle_end battle_end
  def battle_end(result)
    #learn and forget stolen/gained skills
    for actor in $game_party.actors
      if actor.skills_gained.size > 0
        for skill in actor.skills_gained
          actor.forget_skill(skill)
        end
      end
      if actor.skills_lost.size > 0
        for skill in actor.skills_lost
          actor.learn_skill(skill)
        end
      end
    end
    trickster_battle_end(result)
  end
end