#------------------------------------------------------------------------------------------------
#Scvript qui gère les boucliers.
#Pour l'utiliser, il faudra mettre dans les commentaires des compétences:
#<shield hp=H mp=M reg=R/>
#où H est le nombre de pv maximum du bouclier
#où M est le coût en mana par tour pour entretenir le bouclier
#où R est le taux de regénération du bouclier en % par tour
# <shield/> Pour désactiver le bouclier!
#------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------
#Je crée un module à mon nom pour éviter les problèmes de compatibilité
#------------------------------------------------------------------------------------------------
module Valer
  M_DESTROYED = ["Le bouclier de %s a cédé!","Le bouclier de %s a été détruit!","%s n'a plus de bouclier."]
  M_LOWMP=[["Le bouclier de %s s'abime de %d PV.","Il a consommé %d PM."],["Le bouclier de %s a perdu %d PV.","Il a utilisé %d PM."]]
  M_HIGHMP=[["Le bouclier de %s a regagné %d PV.","Il a consommé %d PM."],["Le bouclier de %s se régénère de %d PV.","Il a utilisé %d PM."]]
  M_MP=["Le bouclier de %s a consommé %d PM","Le bouclier de %s a utilisé %d PM"]
  M_DAMAGE=[]
  M_REG=[]
  #Temps d'affichage des message
  MESSAGE_TIME1=60
  MESSAGE_TIME2=30
 
#------------------------------------------------------------------------------------------------
#Classe qui gère les boucliers. Elle sera utilisée directement dans Game_Battler.
#Pour l'utiliser, il faudra mettre dans les commentaires des compétences:
#<shield hp=H mp=M reg=R/>
#où H est le nombre de pv maximum du bouclier
#où M est le coût en mana par tour pour entretenir le bouclier
#où R est le taux de regénération du bouclier en % par tour
# <shield/> Pour désactiver le bouclier!
#------------------------------------------------------------------------------------------------
class Shield
  attr_reader :damage
  attr_reader :hp        #PV du bouclier
  attr_reader :maxhp  #PV maximum du bouclier
  attr_reader :targets  #Personnages ou ennemis protégés par le bouclier
  attr_reader :user      #Personnage ou ennemi qui tient le bouclier
 #------------------------------------------------------------------------------------------------
 #Initialisation de l'objet
 #maxhp : pv du bouclier
 #targets : personnages protégés par le bouclier
 #mp : Coût en PM par tour
 #reg : Taux de regénération en pourcentage par tour
 #------------------------------------------------------------------------------------------------
  def initialize(user,maxhp=0,mp=0,reg=0,targets=nil,charge=false)
  @maxhp=maxhp
  @damage=0
  @hp=maxhp
  @mp=mp
  @reg=reg
  @user=user
  @targets=targets
  @charge=false
  #Lutte contre les usages malattentionnés
  if (@user==nil or maxhp==0)
    return nil
  end
  #s'il n'y a pas de cible, alors c'est l'utilisateur qui utilise son bouclier
  if (@targets==nil)
    @targets=[@user]
  end
  #Gestion des compétences pour un acteur!
  end
 #------------------------------------------------------------------------------------------------
 #Entretient du bouclier
 #On retourne une phrase ou deux pour expliquer ce qui s'est passé
 #------------------------------------------------------------------------------------------------
  def maintain
    result={"damage"=>0,"mp"=>@mp,"destroyed"=>false}
    s=[]
    #Le combattant a plus de MP que ce que demande l'entretien du bouclier
    if (@user.mp>@mp)
    #Mise à jour des dommages
    result["damage"]=-(@maxhp*(@reg.to_f/100.0)).to_i
      #On regénère le bouclier
    @hp-=result["damage"]
    #IOn bride les pv du bouclier
    if (@hp>@maxhp)
      result["damage"]+=@hp-@maxhp
      @hp=@maxhp
    end
    #IOn diminue les PM de l'utilisateur
    @user.mp-=@mp
    #Si le combattant a moins  de MP demandés par l'entretien du bouclier
    else
      #Mise à jour des dommages
      result["damage"]=@maxhp*(@reg*(2*(@user.mp-@mp/2)/@mp)/100)
      #On regénère mal le bouclier (voir on le détruit!)
      @hp-=result["damage"]
      #On bride les pv du bouclier
      if (@hp>@maxhp)
      result["damage"]+=@hp-@maxhp
      @hp=@maxhp
      end
      #Mise à jour des PM consommés
      result["mp"]=@user.mp
      #IOn diminue les PM de l'utilisateur
      @user.mp=0
      #On teste si le bouclier n'est pas détruit
      if @hp<=0
      @hp=0
      result["destroyed"]=true
      #On détruit le bouclier
      end
    end
    #On construit une <<phrase>> pour expliquer ce qui s'est passé>
    #1) Le bouclier est détruit!
    @damage=result["damage"]
    if (result["destroyed"]==true)
      s[0]=sprintf(Valer::M_DESTROYED[rand(Valer::M_DESTROYED.size-1)],@user.name)
    #1) Le bouclier est endommagé!
    elsif (result["damage"]>0)
      s[0]=sprintf(Valer::M_LOWMP[rand(Valer::M_LOWMP.size-1)][0],@user.name,result["damage"])
      s[1]=sprintf(Valer::M_LOWMP[rand(Valer::M_LOWMP.size-1)][1],result["mp"])
    #1) Le bouclier regagne des PV!
    elsif (result["damage"]<0)
      s[0]=sprintf(Valer::M_HIGHMP[rand(Valer::M_LOWMP.size-1)][0],@user.name,-result["damage"])
      s[1]=sprintf(Valer::M_HIGHMP[rand(Valer::M_LOWMP.size-1)][1],result["mp"])
    else
      s[0]=sprintf(Valer::M_MP[rand(Valer::M_DESTROYED.size-1)],@user.name,result["mp"])
    end
    return s
  end
  #------------------------------------------------------------------------------------------------
  #Méthode qui détermine si un personnage est protégé par ce bouclier
  #------------------------------------------------------------------------------------------------
  def with?(target)
    for i in 0..@targets.size-1
    #--------------------------------------------------------------------------
    # Teste si le personnage existe
    #--------------------------------------------------------------------------
      if @targets[i]!=nil and target!=nil
        #--------------------------------------------------------------------------
        # Teste si les deux persos sont du même type
        #--------------------------------------------------------------------------
        if (target.actor?)==@targets[i].actor?
          #--------------------------------------------------------------------------
          # Teste si le personnage est un acteur
          #--------------------------------------------------------------------------
          if (target.actor?)==true
            #--------------------------------------------------------------------------
            # Teste si c'est le même acteur
            #--------------------------------------------------------------------------
            if target.id==@targets[i].id
              return true
            end
          else
            #--------------------------------------------------------------------------
            # Teste si c'est le même ennemi
            #--------------------------------------------------------------------------
            if (target.enemy_id==@targets[i].enemy_id) and (target.index==@targets[i].index)
              return true
            end
          end
        end
      end
    end
    return false
  end
  #------------------------------------------------------------------------------------------------
  #Gestion des dommages reçus par le bouclier
  #Entrée target :
  #Celui qui se fait taper dessus!
  #hp : Inflige des dégâts directs au bouclier
  #Dégâts par ordre :
  #hp
  #hp_damage
  #mp_damage
  #On retourne une phrase ou deux pour expliquer ce qu'il s'est passé!
  #------------------------------------------------------------------------------------------------
 
  def damage(target,hp=0)
    result={"damage"=>0,"mp"=>0,"destroyed"=>false}
    s=[]
    #Teste si la cible de l'attaque est protégée par le bouclier.
    if with?(target)==true
    #Première attaque
    #Si le bouclier peut supporter l'attaque "hp"
    if (@hp>hp)
      result["damage"]+=hp
      @hp-=hp
      #Gestion de la surchage du bouclier
      if @charge==true
      case(rand((100*hp/@maxhp).to_i))
      #Surcharge du bouclier
      when(50..100)
      result["mp"]=@mp
      #L'utilisateur du bouclier ne peut pas parer la surcharge!
      if @mp>@user.mp
        result["mp"]=@user.mp
        @user.mp=0
        result["destroyed"]=true
      end
      #Rien ne se passe
      else
      end
      end
      #Seconde attaque
      #Si le bouclier peut supporter l'attaque "physique"
      if (@hp>target.hp_damage)
      if target.hp_damage>0
        result["damage"]+=target.hp_damage
        @hp-=target.hp_damage
        #Gestion de la surchage du bouclier
        if @charge==true
          case(rand((100*target.hp_damage/@maxhp).to_i))
          #Surcharge du bouclier
          when(50..100)
            result["mp"]+=@mp
            #L'utilisateur du bouclier ne peut pas parer la surcharge!
            if @mp>@user.mp
              result["mp"]=@user.mp
              @user.mp=0
              result["destroyed"]=true
            end
            #Rien ne se passe
          else
          end
        end
      end
      target.hp_damage=0
      #Troisième attaque!
      #Si le bouclier peut supporter l'attaque "psychique"
      if (@mp>target.mp_damage)
      if target.mp_damage>0
        result["damage"]+=target.mp_damage
        @hp-=target.mp_damage
        #Gestion de la surchage du bouclier
        if @charge==true
          case(rand((100*target.mp_damage/@maxmp).to_i))
          #Surcharge du bouclier
          when(50..100)
            result["mp"]+=@mp
            #L'utilisateur du bouclier ne peut pas parer la surcharge!
            if @mp>@user.mp
              result["mp"]=@user.mp
              @user.mp=0
              result["destroyed"]=true
            end
            #Rien ne se passe
          else
          end
        end
      end
      target.mp_damage=0
      #Si le bouclier ne peut pas supporter l'attaque "psychique"
      else
        target.mp_damage-=@hp
        result["damage"]+=@hp
        result["destroyed"]=true
        @hp=0
      end
      #Si le bouclier ne  peut pas supporter l'attaque "physique"
      else
        target.hp_damage-=@hp
        result["damage"]+=@hp
        result["destroyed"]=true
        @hp=0
      end
    #Si le bouclier ne  peut pas supporter l'attaque "hp"
    else
      result["damage"]+=@hp
      result["destroyed"]=true
              @hp=0
      end
    end
  @damage=result["damage"]
 
    #On construit des <<phrases>> pour expliquer ce qui s'est passé>
    s[0] = "Le bouclier de " + @user.name + " a perdu " + result["damage"].to_s + " PV!"
    if result["mp"]>0
    s[1]="Il a consommé " + result["mp"].to_s + " PM!"
    end
    if result["destroyed"]==true
      s[s.size]="Le bouclier est détruit!"
    end
    return s
  end
  def terminate
    @user.shield=nil
  end
 end

end

class Game_Troop < Game_Unit 
  #------------------------------------------------------------------------------------------------
  #On fait des dommages aux boucliers
  #------------------------------------------------------------------------------------------------
  def damage_shield(target,hp=0)
    text=[]
    j=0
    for i in 0..members.size-1
      # * On affiche le texte de l'entretien du bouclier 
      if (members[i].shield!=nil)
        if members[i].shield.hp>0
        text[j]=members[i].shield.damage(target,hp)
          j+=1
        else
          members[i].shield.terminate
        end
      end
    end
    return text
  end
end
class Game_Actors 
  #------------------------------------------------------------------------------------------------
  #On arrête les boucliers
  #------------------------------------------------------------------------------------------------
 def shields_end
    for i in 1..@data.size-1
      if @data[i].shield!=nil
    @data[i].shield.terminate
    @data[i].shield=nil
    end
    end
  end
    #------------------------------------------------------------------------------------------------
  #On fait des dommages aux boucliers
  #------------------------------------------------------------------------------------------------
  def damage_shield(target,hp=0)
    text=[]
    j=0
    for i in 1..@data.size-1
      # * On affiche le texte de l'entretien du bouclier 
      if (@data[i]!=nil)
        if (not @data[i].shield==nil)
          if @data[i].shield.hp>0
          text[j]=@data[i].shield.damage(target,hp)
          j+=1
        else
          @data[i].shield.terminate
        end
        end
      end
    end
    return text
  end
end
class Game_Battler
  attr_accessor  :hp_damage            # action results: HP damage
  attr_accessor  :mp_damage              # action results: MP damage
  attr_accessor :shield #Je rajoute le bouclier
  attr_reader :shield_text
  #--------------------------------------------------------------------------
  # * Alias
  #--------------------------------------------------------------------------
  alias initialize_valer initialize
  alias make_attack_damage_value_valer make_attack_damage_value
  alias make_obj_damage_value_valer make_obj_damage_value
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    initialize_valer
    @shield=nil #on le met à nil pour avoir la paix!
  end
  #--------------------------------------------------------------------------
  # Modification de la gestion des dégats.
  #--------------------------------------------------------------------------
  def make_attack_damage_value(attacker)
  make_attack_damage_value_valer(attacker)
      #Gestion du bouclier
            @shield_text=[]
    if @missed==false
      if (self.shield!=nil and @hp_damage>0)
          if (self.actor?)==true
        @shield_text=$game_actors.damage_shield(self,0)
      else
        @shield_text=$game_troop.damage_shield(self,0)
        end
      end
    end
  end
  def make_obj_damage_value(user, obj)
      make_obj_damage_value_valer(user,obj)
      #Gestion du bouclier
    @shield_text=[]
    if @missed==false
      if (self.shield!=nil and @hp_damage>0)
          if (self.actor?)==true
        @shield_text=$game_actors.damage_shield(self,0)
      else
        @shield_text=$game_troop.damage_shield(self,0)
        end
      end
    end
  end
end

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

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # * Alias
  #--------------------------------------------------------------------------
  alias execute_action_skill_valer execute_action_skill
  alias  set_next_active_battler_valer set_next_active_battler
  alias battle_end_valer battle_end
  alias display_hp_damage_valer display_hp_damage
  #--------------------------------------------------------------------------
  #On modifie cette méthode pour pouvoir entretenir le bouclier!
  #--------------------------------------------------------------------------
  def set_next_active_battler
if (@active_battler!=nil)
    if (@active_battler.shield!=nil)
      if (@active_battler.shield.hp>0)
      text=@active_battler.shield.maintain
            @message_window.clear
      for i in 0..text.size-1
      @message_window.add_instant_text(text[i])
      end
      wait(  Valer::MESSAGE_TIME2)
      @message_window.clear
    else
      @active_battler.shield.terminate
      end
    end
  end
  set_next_active_battler_valer
  end
    #--------------------------------------------------------------------------
  # *On modifie cette méthode pour générer des boucliers!
  #--------------------------------------------------------------------------
  def execute_action_skill
    execute_action_skill_valer
    skill = @active_battler.action.skill
    targets = @active_battler.action.make_targets
    if (skill.note!=nil and skill.note!="")
      #On coupe le texte lç où il y a des espaces, des <> et des =
      text = skill.note.split(/[\r\n <=\/]+/)
      result={"shield"=>false,"ghost"=>false,"hp"=>0,"mp"=>0,"reg"=>0,"charge"=>"false"}
      for i in 0..text.size-1
        line=text[i]
        case (line)
        #si on a affaire à un bouclier
        when "shield"
        result["shield"]=true
        when "hp"
        result["hp"]=(text[i+1]).to_i
        i+=1
        when "mp"
        result["mp"]=(text[i+1]).to_i
        i+=1
        when "reg"
        result["reg"]=(text[i+1]).to_i
        i+=1
        when "charge"
          if text[i+1]==true
            result["charge"]=true
            i+=1
          elsif  text[i+1]==false
            result["charge"]=false
            i+=1 
       
          end
        when ">"
          if result["shield"]==true
            @active_battler.shield=Valer::Shield.new(@active_battler,result["hp"],result["mp"],result["reg"],targets)
            result={"shield"=>false,"ghost"=>false,"hp"=>0,"mp"=>0,"reg"=>0,"charge"=>"false"}
          end
        end
      end
    end
  end
    #--------------------------------------------------------------------------
  # A la fin de la bataille, on désactive les boucliers!
  #--------------------------------------------------------------------------
  def battle_end(result)
    $game_actors.shields_end
    battle_end_valer(result)
  end
  #--------------------------------------------------------------------------
  # * Show HP Damage
  #--------------------------------------------------------------------------
    def display_hp_damage(target, obj = nil)
      display_shield_damage(target)
      display_hp_damage_valer(target,obj)
    end
  #--------------------------------------------------------------------------
  # * Show shield Damage
  #--------------------------------------------------------------------------
  def display_shield_damage(target)
    if target.shield !=nil
      k=0
        @message_window.clear
      for i in 0..target.shield_text.size-1
        for j in 0..target.shield_text[i].size-1
        k=k+1
        @message_window.add_instant_text(target.shield_text[i][j])
        if k%4==0
          wait(Valer::MESSAGE_TIME1)
          @message_window.clear
        end
      end
    end
    wait( Valer::MESSAGE_TIME2)
      @message_window.clear
    end
  end   
end

#=============================================================================#
#Pour utiliser ce script : Placez le script après le SBS.
#Pour utiliser les boucliers:
#Mettre dans le commentaire de la compétence :
#<shield>
#hp =                      #Nombre de PV du bouclier
#mp =                      #Nombre de PM utilisé par tour
#reg =                      #Taux de regénération par tour
#safe =                    #Fiabilité du bouclier :)
#damage =              #Dommage infiligé au possesseur du bouclier quand celui-ci explose
#graphics = chemin #Chemin des graphisme de votre bouclier
#x =                          # Nombre de colonnes sur votre image
#y =                          # Nombre de lignes sur votre image
#</shield>
#Dans le module Configuration
#Valeurs par défauts
#HP
#MP
#SAFE
#DAMAGE
#REG

#ACTOR_GRAPHICS : Images du bouclier pour les héros (Il faut les stocker dans Character).
#ACTOR_X : Nombre de collones sur votre image
#ACTOR_Y : Nombre de lignes sur votre image

#ENNEMY_GRAPHICS : Images du bouclier pour les méchants (Il faut les stocker dans Character)
#ENNEMY_X : Nombre de colonnes sur votre image
#ENNEMY_Y : Nombre de lignes sur votre image

#Autre sur le format des images :
#Vous devez mettres les différents boucliers en collones par ordre décroissant de point de vie, en effet le bouclier change en fonction de ses points de vie. Par contre, les lignes sont les variations naturelles du bouclier

module Shield
  #Default HP
  HP = 100
  #Default MP cost
  MP = 10
  #Safety
  SAFE = 100
  DOMMAGES = 100
  #Regeneration
  REG = 10
  #Graphics
  ACTOR_GRAPHICS="shield"
  ACTOR_X=3
  ACTOR_Y=4
 
  ENNEMY_GRAPHICS= ""
  ENNEMY_X=3
  ENNEMY_Y=4
end

class Game_Shield
  attr_reader:actived
  attr_reader:mp_damage
  attr_reader:hp_damage
  attr_reader:mp
  attr_reader:hp
  attr_reader:maxhp
  attr_reader:safe
  attr_reader:graphics
  attr_reader:reg
  attr_reader:dead
  attr_reader:x
  attr_reader:y
 #------------------------------------------------------------------------------------------------
 #Initialisation de l'objet
 # actor est le personnage qui génére le bouclier
 #------------------------------------------------------------------------------------------------
 def initialize(actor)
  @actor=actor
    @actived = false
 end
 #------------------------------------------------------------------------------------------------
 #Suppression du bouclier
 #------------------------------------------------------------------------------------------------
  def stop
    if @actived
      @reg = 0
     
      @maxhp = 0
      @hp = 0
   
      @mp = 0
   
      @safe=0
      @maxsafe = 0
      @damage = 0
      @dead=false
   
      @actived = false
    end
  end
#------------------------------------------------------------------------------------------------
 #Composante par défaut du bouclier
 #------------------------------------------------------------------------------------------------
  def setup
      @reg = Shield::REG
     
      @maxhp = Shield::HP
      @hp = Shield::HP
   
      @mp = Shield::MP
   
      @safe=Shield::SAFE
      @maxsafe = Shield::SAFE
      @damage = Shield::DOMMAGES
   
      @actived =true
      @dead=false
     
      if @actor.actor?
        @graphics = Shield::ACTOR_GRAPHICS
        @x=Shield::ACTOR_X
        @y=Shield::ACTOR_Y
      else
        @graphics = Shield::ENNEMY_GRAPHICS
        @x=Shield::ENNEMY_X
        @y=Shield::ENNEMY_Y
      end
  end
 #------------------------------------------------------------------------------------------------
 #Génération du bouclier
 # text est les commentaires de la compétence
 #------------------------------------------------------------------------------------------------
  def start(text)
    if (text!=nil and text!="")
      text = text.split(/[\r\n =\t\"]+/)
      shield = false
      for i in 0..text.size-1
        line=text[i]
        case (line)
        #si on a affaire à un bouclier
          when "<shield>"
            shield=true
            setup
          when "hp"
            if shield
              @maxhp=(text[i+1]).to_i
              @hp=@maxhp
              i += 1
            end
          when "x"
            if shield
              @x=(text[i+1]).to_i
              i += 1
            end
          when "y"
            if shield
              @y=(text[i+1]).to_i
              i += 1
            end
          when "mp"
            if shield
              @mp=(text[i+1]).to_i
              i += 1
            end
          when "graphics"
            if shield
              @graphics=(text[i+1])
              i += 1
            end
          when "reg"
            if shield
              @reg=(text[i+1]).to_i
              i+=1
            end
          when "safe"
            if shield
              @safe=(text[i+1]).to_f
              @maxsafe = @safe
              i+=1
            end
          when "damage"
            if shield
              @damage=(text[i+1]).to_i
              i+=1
            end
          when "</shield>"
            if shield
              shield=false
            end
          else
        end
      end
    end
  end
 #------------------------------------------------------------------------------------------------
 #Entretient du bouclier
 #------------------------------------------------------------------------------------------------
  def maintain
    #Sans commentaires
    @hp_damage = 0
    @mp_damage = 0
    @dead=false
    if @actived
      #Utilisation des MP
      #Le combattant a plus de PM que ce que demande l'entretien du bouclier
      if (@actor.mp>@mp)
        #Modification des PV du boucliers
          @hp_damage = @hp
          @hp=[(@hp+(@maxhp*(@reg/100.0)).to_i),@maxhp].min
          @hp_damage= @hp_damage - @hp
        #Mise à jour des PM
          @actor.mp-=@mp
          @mp_damage=@mp
      #Si l'utilisateur a au moins la moité de ce que demande l'entretient du bouclier
      elsif @actor.mp-@mp/2>0
          #Modification des PV du boucliers
            @hp_damage = @hp
            @hp=[(@hp+@maxhp*(@reg*(2*(@actor.mp-@mp/2)/@mp)/100.0)),@maxhp].min
            @hp_damage= @hp_damage - @hp
            #Mise à jour des PM
            @mp_damage=@actor.mp
            @actor.mp=0
      #Si l'utilisateur ne peut plus entretenir correctement son bouclier
      else
        #Mise à jour des dommages
          @hp_damage = @hp
          @hp=[(@hp+@maxhp*(@actor.mp-@mp/2)/@mp),0].max
        #Mise à jour des PM
          @hp_damage= @hp_damage - @hp
          @mp_damage=@actor.mp
          @actor.mp=0
        #Test si le bouclier est détruit
          if @hp==0
            @actived = false
            @dead=true
          end
      end
    end
  end
 #------------------------------------------------------------------------------------------------
 #Calcul les dégats au bouclier
 #------------------------------------------------------------------------------------------------
  def damage
    #Teste si le bouclier est activé
    @hp_damage = 0
    @mp_damage = 0
    if @actived
      @hp_damage = @hp
      @hp = [[@hp - (@actor.hp_damage+@actor.mp_damage),0].max,@maxhp].min
      @hp_damage= @hp_damage - @hp
      temp = [@hp_damage,@actor.hp_damage].min
      @actor.hp_damage-=temp
      @actor.mp_damage-=(@hp_damage - temp)
      if @hp == 0
        @actived = false
        @dead=true
      else
        temp = rand(101)
        if temp>@safe
          @actor.hp_damage = @actor.hp_damage + @damage
          @actived = false
          @dead=true
        end
      end
    end
  end

  #------------------------------------------------------------------------------------------------
  #Dégâts spéciaux
  #damage est les dégats au bouclier
  #safe réduit la sécurité du bouclier
  #------------------------------------------------------------------------------------------------
  def skill_damage(damage,safe)
    #Teste si le bouclier est activé
    if @actived
      @hp_damage = @hp_damage + @hp
      @hp = [[@hp - damage,0].max,@maxhp].min
      @hp_damage= @hp_damage - @hp
      @safe -=safe
      if @hp == 0
        @actived = false
        @dead=true
      else
        temp = rand(101)
        if temp>@safe
          @actor.hp_damage += @damage
          @actived = false
          @dead=true
        end
      end
    end
    return 0
  end
end
class Game_Battler
  attr_accessor  :hp_damage            # action results: HP damage
  attr_accessor  :mp_damage              # action results: MP damage
  attr_reader :shield            #Bouclier
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize_shield_2
    @shield=Game_Shield.new(self)
  end
  alias initialize_shield initialize
  def initialize
    initialize_shield
    initialize_shield_2
  end
  #--------------------------------------------------------------------------
  # Modification de la gestion des dégats.
  #--------------------------------------------------------------------------
  alias make_attack_damage_value_shield make_attack_damage_value
  def make_attack_damage_value(attacker)
  make_attack_damage_value_shield(attacker)
    @shield.damage
  end
  alias make_obj_damage_value_shield make_obj_damage_value
  def make_obj_damage_value(user, obj)
    make_obj_damage_value_shield(user,obj)
    @shield.damage
  end
end
class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  #Entretien du bouclier en fin de tour du joeueur
  #--------------------------------------------------------------------------
  alias  set_next_active_battler_shield set_next_active_battler 
  def set_next_active_battler_shield2
    if (@active_battler!=nil)
      @active_battler.shield.maintain
    end
  end
  def set_next_active_battler
  set_next_active_battler_shield2
  set_next_active_battler_shield
 end
  #--------------------------------------------------------------------------
  # Lancement du bouclier
  #--------------------------------------------------------------------------
  alias execute_action_skill_shield execute_action_skill
  def execute_action_shield2(skill)
    @active_battler.shield.start(skill.note)
  end
  def execute_action_skill
    execute_action_skill_shield
    execute_action_shield2(@active_battler.action.skill)
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  alias terminate_shield1 terminate
  def terminate
    terminate_shield1
    for member in $game_party.members
      member.shield.stop
    end
  end
end

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  #On affiche les dégats du bouclier
  #--------------------------------------------------------------------------
  def display_shield_damage(target)
        if target.shield!=nil
          if target.shield.hp_damage!=0
            if target.hp_damage != 0
              wait(N01::NUM_DURATION)
            end
            if target.hp_damage!=0
              wait(N01::NUM_DURATION)
            end
            @spriteset.set_shield_damage_pop(target.actor?,target.index,0)
            end
          end
  end
  #--------------------------------------------------------------------------
  #On écrase l'ancienne méthode pour faire s'afficher l'entretient du bouclier
  #--------------------------------------------------------------------------
  def set_next_active_battler_shield2
    if (@active_battler!=nil)
      @active_battler.shield.maintain
    if @active_battler.shield.mp_damage!=0
      @spriteset.set_shield_damage_pop(@active_battler.actor?,@active_battler.index,1)
    end
    if @active_battler.shield.hp_damage!=0
      wait(N01::NUM_DURATION)
      @spriteset.set_shield_damage_pop(@active_battler.actor?,@active_battler.index,0)
    end
    end
  end
  alias damage_action_shield damage_action
  def damage_action(action)
    damage_action_shield(action)
    for target in @targets
      display_shield_damage(target)
    end
  end
end
class Sprite_Battler < Sprite_Base
  def damage_pop_shield(type)
    @damage.damage_pop_shield(@battler.shield,type)
  end 
end
class Spriteset_Battle
  def set_shield_damage_pop(actor, index,type)
    @actor_sprites[index].damage_pop_shield(type) if actor
    @enemy_sprites[index].damage_pop_shield(type) unless actor
  end
end
#==============================================================================
# ■ Sprite_Damage
#------------------------------------------------------------------------------
#==============================================================================
class Sprite_Damage < Sprite_Base
  attr_accessor :battler
  def damage_file_shield(num, cw, dur,graphics=0)
    num.visible = true
    case(graphics)
      when(0)
        file = N01::DAMAGE_GRAPHICS
        file = N01::RECOVER_GRAPHICS if @minus
      else
        file = N01::MP_DAMAGE_GRAPHICS
        file = N01::MP_RECOVER_GRAPHICS if @minus
    end
    num.bitmap = Cache.system(file)
    @num_time += 1
    sx = num.bitmap.width / 10
    num.src_rect.set(cw * sx, 0, sx, num.height)
    num.x = @x - (num.width + N01::NUM_INTERBAL) * @num_time
    num.y = @y
    num.z = 2000 - @num_time
    @duration = dur
    @window.x = num.x - @window.width + 64 if @window != nil && N01::NON_DAMAGE_WINDOW
    @window.x = num.x - @window.width + 26 if @window != nil && !N01::NON_DAMAGE_WINDOW
    @window.x = 0 if @window != nil && @window.x < 0
  end
  def damage_pop_shield2(type,damage)
    @minus = false
    @minus = true if damage < 0
    damage = damage.abs
    adjust = -16
    adjust = 16 if $back_attack
    adjust = 0 if damage == 0
    damage_file_shield(@num1, damage % 10, @pop_time - 7,type) if damage >= 0
    damage_file_shield(@num2, (damage % 100)/10, @pop_time - 5,type) if damage >= 10
    damage_file_shield(@num3, (damage % 1000)/100, @pop_time - 3,type) if damage >= 100
    damage_file_shield(@num4, (damage % 10000)/1000, @pop_time - 1,type) if damage >= 1000
    damage_file_shield(@num5, (damage % 100000)/10000, @pop_time + 1,type) if damage >= 10000
  end
 
  def damage_pop_shield(shield,type)
    reset
    @x = battler.position_x
    @y = battler.position_y
    @pop_time = N01::NUM_DURATION
    @num_time = -1
    if not shield.actived
      if shield.dead
        if shield.hp>0
          text = "Explosion!"
        else
          text="Bouclier détruit!"
        end
      else
        return
      end
    else
    if (type==0)
      damage_pop_shield2(0,shield.hp_damage)
      @pop_time+=N01::NUM_DURATION
    end
    if (type==1)
      damage_pop_shield2(1,shield.mp_damage)
      @pop_time+=N01::NUM_DURATION
    end
    return
    end
    window(text) if text != ""
  end 
end
class Sprite_Shield < Sprite
  def initialize(battler_sprite,cy=2)
    super(battler_sprite.viewport)
    @battler_sprite = battler_sprite
    @cy = cy
    @sens=cy-1
    @hue = -4
    @shield = @battler_sprite.battler.shield
    @pas = 1/[(@shield.x-1),0.5].max
    self.visible = true
    make_shield
  end
  def make_shield
    if @battler_sprite.battler_hue!=@hue
      self.bitmap =  Cache.character(@shield.graphics,@hue) 
      @hue = @battler_sprite.battler_hue
      @w=self.bitmap.width/@shield.x
      @h=self.bitmap.height/@shield.y
    end
    self.x=@battler_sprite.x
    self.y=@battler_sprite.y
    self.z=@battler_sprite.z+@sens
  end
 
 
  def update
    super
    make_shield
    cx = 0
    r = (1.0 * @shield.hp) /(1.0*@shield.maxhp)
    value=1
    for i in @shield.x-1..0
      value-=@pas
      if r>v
        cx=i
        i=0
      end
    end
    self.src_rect.set(cx*@w,@cy*@h,@w,@h)
    self.ox = self.width / 2
    self.oy = self.height * 2 / 3
    @cy+=1
    @cy%=4
  end
end
#==============================================================================
# ■ Sprite_Battler  for Sideview Ver3.3d
#------------------------------------------------------------------------------
# 　バトラー表示用のスプライトです。
#==============================================================================
class Sprite_Battler < Sprite_Base
  attr_reader:battler_hue
  attr_reader:battler
  #--------------------------------------------------------------------------
  # ● フレーム更新　※再定義
  #--------------------------------------------------------------------------
  def update
    super
    # バトラーがいない場合スキップ
    return self.bitmap = nil if @battler == nil
    update_shield
    # バトラー追加
    battler_join
    # 次のアクションへ
    next_action
    # アニメパターン更新
    update_anime_pattern
    # ターゲット更新
    update_target
    # 強制アクション更新
    update_force_action
    # 座標更新
    update_move
    # 影更新
    update_shadow if @shadow != nil
    # 武器更新
    @weapon_R.update if @weapon_action
    # 浮遊更新
    update_float if @float_time > 0
    # 回転更新
    update_angle if @angle_time > 0
    # 拡大縮小更新
    update_zoom if @zoom_time > 0
    # 残像更新
    update_mirage if @mirage_flug
    # ピクチャ更新
    update_picture if @picture_time > 0
    # アニメ飛ばし更新
    update_move_anime if @anime_moving
    # ふきだしアニメ更新
    update_balloon if @balloon_duration <= 64
    # ダメージスプライト更新
    @damage.update if @damage != nil
    setup_new_effect
    update_effect
    update_battler_bitmap
  end
  def update_shield
    @damage.update if @damage != nil
    if @sprite_shield==nil
      if @battler.shield.actived
        @sprite_shield=Sprite_Shield.new(self)
        @sprite_shield_back = Sprite_Shield.new(self,0)
        @sprite_shield.update
        @sprite_shield_back.update
      end
    else
      if not @battler.shield.actived
        @sprite_shield.dispose
        @sprite_shield_back.dispose
        @sprite_shield=nil
        @sprite_shield_back=nil
      else
        @sprite_shield.update
        @sprite_shield_back.update
      end
    end
  end
end