###################################
#
#                  Modifs globale
#
###################################
=begin        MODE D'EMPLOI
Ce script redefini un certain nombre de methode pour ajouter les effets du terrain.
Pour eviter les incompatibilités, placez le en haut de "Materials".
=end
###################################
class Game_Actor < Game_Battler
  def base_atk
    n = actor.parameters[2, @level]
    for item in equips.compact do n += item.atk end
###
    bonus = get_terrain_effet(n, "atk")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end
 
  def base_def
    n = actor.parameters[3, @level]
    for item in equips.compact do n += item.def end
###
    bonus = get_terrain_effet(n, "def")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end

  def base_spi
    n = actor.parameters[4, @level]
    for item in equips.compact do n += item.spi end
###
    bonus = get_terrain_effet(n, "spi")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end
 
  def base_agi
    n = actor.parameters[5, @level]
    for item in equips.compact do n += item.agi end
###
    bonus = get_terrain_effet(n, "agi")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end
 
  def skills
    result = []
    for i in @skills
      result.push($data_skills[i])
    end
###
    result |= get_terrain_skill  ## Ajout
###
    return result
  end
 
  def hit
    if two_swords_style
      n1 = weapons[0] == nil ? 95 : weapons[0].hit
      n2 = weapons[1] == nil ? 95 : weapons[1].hit
      n = [n1, n2].min
    else
      n = weapons[0] == nil ? 95 : weapons[0].hit
    end
###
    bonus = get_terrain_effet(n, "hit")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end
 
  def eva
    n = 5
    for item in armors.compact do n += item.eva end
###
    bonus = get_terrain_effet(n, "eva")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end
 
  def cri
    n = 4
    n += 4 if actor.critical_bonus
    for weapon in weapons.compact
      n += 4 if weapon.critical_bonus
    end
###
    bonus = get_terrain_effet(n, "cri")  ## Ajout
    n = bonus == nil ? n : bonus
###
    return n
  end
 
  def element_rate(element_id)
    rank = self.class.element_ranks[element_id]
    result = [0,200,150,100,50,0,-100][rank]
    for armor in armors.compact
      result /= 2 if armor.element_set.include?(element_id)
    end
    for state in states
      result /= 2 if state.element_set.include?(element_id)
    end
###
    bonus = get_terrain_effet(result, "elt", element_id)  ## Ajout
    result = bonus == nil ? result : bonus
###
    return result
  end
 
  def state_probability(state_id)
    if $data_states[state_id].nonresistance
      return 100
    else
      rank = self.class.state_ranks[state_id]
      result = [0,100,80,60,40,20,0][rank]
###
      bonus = get_terrain_effet(result, "etat", state_id)  ## Ajout
      result = bonus == nil ? result : bonus
###
      return result
    end
  end
end
###################################

###################################
#
#                        Add-on GTBS
#                      Effet de terrain
#
###################################
=begin          MODE D'EMPLOI
Attention, cet add-on ne peut fonctionner que si vous utilisez le Multiple-Tilesets !!
Il utilise l'option "ID de terrain" que celui mets à la disposition des utilisateurs de VX.
Configurer les ID de terrain dans l'editeur du Multiple-Tilesets et indiquez ci-dessous leurs effets.
Les effets de terrains peuvent etre differents selon les battlers.
Pour les héros, tout ce configure dans le module ci-dessous.
Pour les ennemis, il faut indiquer dans leurs note de quel "type" ils sont.
( La signification des "types" est detaillés ci-dessous )
Pour definir un type, il suffit d'inscrire    TERRAIN_TYPE=2    dans la note.
( L'ennemi sera ainsi de type 2, les effets seront differents des ennemis de types 1 ou 5 ... )
Si rien n'est defini, ils seront par defaut de type 0, soit "Aucun effet"
=end
###################################
module GTBS_terrain
# Indiquer ici le type des differents héros :
#  Id du héros => type associé.
# Les héros non defini ont le type 0 ( Aucun effet )
  Heros_type = { 1 => 2, 7 => 1, 9 => 2 }
 
# Indiquer ici les effets des differents terrains selon le type du battler :
  Effet_terrain = {}
# Configuration pour le type 1
#  On associe une ID de terrain à un effet et à une couleur de texte
# ( Vous pouvez definir vos couleurs tout en bas du script !! )
# L'ID de terrain 0 est celle où il n'y a jamais d'effet !!
# Les ID non defini n'ont pas d'effet non plus.
# Les ID pouvant aller jusque 99.
  Effet_terrain[1] = { 1 => ["atk_up[50]", "jaune"],
                                  2 => ["elt(9)_down[25]", "jaune"],
                                  3 => ["def_down[15]", "bleu"],
                                  4 => ["etat(2)_up[50]", "vert"],
                                  5 => ["agi_up[5]", "noir"],
                                  6 => ["spi_down[25]", "blanc"]  }
# Configuration pour le type 2
  Effet_terrain[2] = { 1 => ["skill[62]", "rouge"],
                                  2 => ["hit_up[12]", "vert"],
                                  3 => ["eva_down[74]", "bleu"],
                                  4 => ["cri_up[29]", "jaune"],
                                  5 => ["hp_down[25]", "noir"],
                                  6 => ["mp_up[10]", "blanc"]  }
# Créer autant de type que vous voulez !!
###################################
=begin            LISTE DES EFFETS

Il existe plusieurs effets combinant un prefixe, un suffixe et une valeur :
Exemple = atk_up[50]  => augmentation de 50 % de la force
Leurs formes est  =>  prefixe + _ + suffixe + [ + valeur + ]

Prefixe : "atk", "def", "agi" et "spi" designe les stats des héros
"hit" designe la precision
"eva" designe l'evasion, l'esquive
"cri" designe le taux de coup critique ( eviter les "grosses" modifications sauf effet voulu )

"etat" designe le resistance aux changements d'etats
Exemple : "etat(2)_up[50]" => augmentation de 50 % de la resistance au "Poison"
"elt" designe la resistance aux attaques elementaires
Exemple : "elt(9)_down[25]" => diminution de 25 % de la resistance face aux magies de type "Feu"

Il existe des effets qui intervienne à chaque tour, soit pour infliger des degats, soit pour soigner.
"hp_down[25]"  => Perte de 25 % des HP à chaque tour de presence sur la case ( lave par exemple ).
"mp_up[10]"  => Recuperation de 10 % des MP par tour de presence sur la case ( ville par exemple ).

Suffixe : "up" designe une augmentation
"down" designe une diminution

Valeur : Sauf spécification, la valeur est un pourcentage

Gain de competence :  se presente sous la forme  =>  "skill" + [ + id + ]
Avec l'id de la competence gagné entre crochets
Valable uniquement pour les alliées !!

=end
end
###################################
class String
  def decoupe
    bloc = []
    self.split(/[\r\n]+/).each { |line| bloc.push(line) }
    return bloc
  end
end
###################################
module RPG
  class Enemy
    def terrain_type
      num = 0
      text = @note.decoupe
      for line in text
        if line.include?("TERRAIN_TYPE=")
          num = line.delete("TERRAIN_TYPE=").to_i
        end
      end
      return num
    end
  end
end
###################################
class Game_Battler
  alias hk_terrain_slip_dmg slip_damage?
  def slip_damage?
    effet = get_effet
    if effet != nil
      if effet.include?("hp") or effet.include?("mp")
        return true
      end
    end
    hk_terrain_slip_dmg
  end
  alias hk_terrain_dmg_effet slip_damage_effect
  def slip_damage_effect
    effet = get_effet
    if effet != nil
      if effet.include?("hp")
        new_hp = get_terrain_effet(self.hp, "hp")
        self.damage = self.hp - new_hp
        self.hp = new_hp
        self.damage_pop = true
        return true
      elsif effet.include?("mp")
        new_mp = get_terrain_effet(self.mp, "mp")
        self.damage = self.mp - new_mp
        self.mp = new_mp
        self.damage_pop = true
        return true
      end
    end
    hk_terrain_dmg_effet
  end
  def get_terrain_effet(n, type, or_id = nil)
    return nil unless $scene.is_a?(Scene_Battle_TBS)
    effet = get_effet
    return nil if effet == nil
    return nil unless effet.include?(type)
    num = 0
    id = 0
    effet.gsub(/\(([0-9]+)\)/i) { id = $1.to_i }
    effet.gsub(/\[([0-9]+)\]/i) { num = $1.to_i }
    if effet.include?("up")
      tx = 100 + num
      tx = 100 - num if or_id != nil
    elsif effet.include?("down")
      tx = 100 - num
      tx = 100 + num if or_id != nil
    end
    return n if or_id != nil and or_id != id
    n = ((n * tx) / 100)
    return n
  end
  def get_effet
    type = terrain_type
    return nil if type == 0
    tag = $game_map.terrain_tag(self.x, self.y)
    return nil if tag == 0
    ref = GTBS_terrain::Effet_terrain[type]
    return nil unless ref.key?(tag)
    effet = ref[tag]
    return effet[0]
  end
end
###################################
class Game_Actor < Game_Battler
  def terrain_type
    if GTBS_terrain::Heros_type.key?(self.id)
      return GTBS_terrain::Heros_type[self.id]
    else
      return 0
    end
  end
  def get_terrain_skill
    return [] unless $scene.is_a?(Scene_Battle_TBS)
    effet = get_effet
    return [] if effet == nil
    return [] unless effet.include?("skill")
    num = 0
    effet.gsub(/\[([0-9]+)\]/i) { num = $1.to_i }
    return [$data_skills[num]]
  end
  def skill_learn?(skill)
    return skills.include?(skill)
  end
end
###################################
class Game_Enemy < Game_Battler
  def terrain_type
    return enemy.terrain_type
  end
end
###################################
class Info_Terrain < Window_Base
  def initialize(actor, coord)
    h = (2*WLH) + 32
    super(0, 416-h, 160, h)
    refresh(actor, coord)
  end
  def refresh(actor, coord)
    return if actor == nil
    return if coord == []
    if coord != @coord or actor != @actor
      self.contents.clear
      self.contents.font.color = system_color
      self.contents.draw_text(0, 0, 160-32, 24, "Effet :")
      self.contents.font.color = get_effet_color(actor, coord)
      text = get_effet_text(actor, coord)
      self.contents.draw_text(0, 24, 160-32, 24, text, 1)
      @coord = coord
      @actor = actor
    end
  end
  def get_effet_color(actor, coord)
    effet = get_effet(actor, coord)
    if effet != nil
      return color(effet[1])
    else
      return normal_color
    end
  end
  def get_effet_text(actor, coord)
    effet = get_effet(actor, coord)
    return "----------" if effet == nil
    return draw(effet[0])
  end
  def get_effet(actor, coord)
    type = actor.terrain_type
    return nil if type == 0
    tag = $game_map.terrain_tag(coord[0], coord[1])
    return nil if tag == 0
    ref = GTBS_terrain::Effet_terrain[type]
    return nil unless ref.key?(tag)
    effet = ref[tag]
    return effet
  end
  def draw(effet)
    type = ""
    num = nil
    text = ""
    id = 0
    effet.gsub(/\(([0-9]+)\)/i) { id = $1.to_i }
    effet.gsub(/\[([0-9]+)\]/i) { num = $1.to_i }
    if effet.include?("up")
      type = "+"
    elsif effet.include?("down")
      type = "-"
    elsif effet.include?("skill")
      text = "Bonus skill"
    else
      type = effet
    end
    if effet.include?("atk")
      text = "Atk #{type} #{num} %"
    elsif effet.include?("def")
      text = "Def #{type} #{num} %"
    elsif effet.include?("agi")
      text = "Agi #{type} #{num} %"
    elsif effet.include?("spi")
      text = "Mag #{type} #{num} %"
    elsif effet.include?("hit")
      text = "Prc #{type} #{num} %"
    elsif effet.include?("eva")
      text = "Esq #{type} #{num} %"
    elsif effet.include?("cri")
      text = "Crt #{type} #{num} %"
    elsif effet.include?("hp")
      if type == "+"
        text = "Recup. HP #{num} %"
      else
        text = "Dmg. HP #{num} %"
      end
    elsif effet.include?("mp")
      if type == "+"
        text = "Recup. MP #{num} %"
      else
        text = "Dmg. MP #{num} %"
      end
    elsif effet.include?("etat")
      name = $data_states[id].name
      text = "'#{name}' #{type} #{num} %"
    elsif effet.include?("elt")
      name = $data_system.elements[id]
      text = "'#{name}' #{type} #{num} %"
    end
    return text
  end
end
###################################
class Scene_Battle_TBS < Scene_Base
  alias hk_terrain_start start
  def start
    @info_terrain = Info_Terrain.new(nil, [])
    @info_terrain.visible = false
    hk_terrain_start
  end
  alias hk_terrain_update_basic update_basic
  def update_basic(main = false)
    hk_terrain_update_basic(main)
    actor = @active_battler
    coord = [@cursor.x, @cursor.y]
    if actor != nil
      @info_terrain.refresh(actor, coord)
      @info_terrain.visible = true
    else
      @info_terrain.visible = false
    end
  end
  alias hk_terrain_terminate terminate
  def terminate
    @info_terrain.dispose
    hk_terrain_terminate
  end
end
###################################
class Window_Base < Window
  def color(text)
    case text
    when "normal"
      color = normal_color
    when "systeme"
      color = system_color
    when "rouge"
      color = Color.new(255, 0, 0, 255)
    when "noir"
      color = Color.new(0, 0, 0, 255)
    when "jaune"
      color = Color.new(255, 255, 0, 255)
    when "bleu"
      color = Color.new(0, 0, 255, 255)
    when "vert"
      color = Color.new(0, 255, 0, 255)
    when "blanc"
      color = Color.new(255, 255, 255, 255)
    when "gris0"
      color = Color.new(50, 50, 50, 255)
    when "gris1"
      color = Color.new(100, 100, 100, 255)
    when "gris2"
      color = Color.new(150, 150, 150, 255)
    when "gris3"
      color = Color.new(200, 200, 200, 255)
    end
    return color
  end
end
###################################