if VULNE_DAMAGE?
       
        if @hp_damage < 0 #Verifit si les degats son negatif (soin)
            @hp_damage = @hp_damage #les degats ne sont pas doublé
            else
      @hp_damage = @hp_damage * 2
      @mp_damage = @mp_damage
    end
   
    end

<demi_damage>

<quart_damage>

<vulne_damage>

<invulne_damage>

<gourman_damage>

#=================================
###Degat basé sur les états
#Script crée par Lecode234
#30 Novembre 2010
#=================================
#Placer <demi_damage> dans la note d'un etat pour faire en sorte que les degats recus sois diviser par 2

#Placer <quart_damage> dans la note d'un etat pour faire en sorte que les degats recus sois diviser par 3

#Placer <vulne_damage> dans la note d'un etat pour rendre vulnerable un ennemie.Les degats poorté sur
#lui se multiplie par2

#Placer <invulne_damage> dans la note d'un etat pour rendre invulnerable la bicle.il ne recoie aucun degat.

#Placer <gourman_damage> dans la note d'un etat pour faire en sorte que la cible,une fois taper se fait absorber les degats.
#==========================================================================

$imported = {} if $imported == nil
$imported["Advanced damage"] = true

module Lecode_Demi_DAMAGE
  module DemiDamage
    module Regexp
      module State
        DEMI_DAMAGE = /<(?:DEMI_DAMAGE|demi_damage)>/i
          QUART_DAMAGE = /<(?:QUART_DAMAGE|quart_damage)>/i
          VULNE_DAMAGE = /<(?:VULNE_DAMAGE|vulne_damage)>/i
          INVULNE_DAMAGE = /<(?:INVULNE_DAMAGE|invulne_damage)>/i
          GOURMAN_DAMAGE = /<(?:GOURMAN_DAMAGE|gourman_damage)>/i
      end
    end
  end
end

#====================================================
class RPG::State
  #--------------------------------------------------------------------------
  # cache DEMI_DAMAGE
  #--------------------------------------------------------------------------
  def create_DEMI_DAMAGE_cache
    @DEMI_DAMAGE = false

    self.note.each_line { |line|
      case line
      when Lecode_Demi_DAMAGE::DemiDamage::Regexp::State::DEMI_DAMAGE
        @DEMI_DAMAGE = true
      end
    }
  end
    #--------------------------------------------------------------------------
  # cache QUART_DAMAGE
  #--------------------------------------------------------------------------
  def create_QUART_DAMAGE_cache
    @QUART_DAMAGE = false

    self.note.each_line { |line|
      case line
      when Lecode_Demi_DAMAGE::DemiDamage::Regexp::State::QUART_DAMAGE 
        @QUART_DAMAGE = true
      end
    }
  end
  #--------------------------------------------------------------------------
  # cache VULNE_DAMAGE
  #--------------------------------------------------------------------------
  def create_VULNE_DAMAGE_cache
    @VULNE_DAMAGE = false

    self.note.each_line { |line|
      case line
      when Lecode_Demi_DAMAGE::DemiDamage::Regexp::State::VULNE_DAMAGE
        @VULNE_DAMAGE = true
      end
    }
end
  #--------------------------------------------------------------------------
  # cache INVULNE_DAMAGE
  #--------------------------------------------------------------------------
  def create_INVULNE_DAMAGE_cache
    @INVULNE_DAMAGE = false

    self.note.each_line { |line|
      case line
      when Lecode_Demi_DAMAGE::DemiDamage::Regexp::State::INVULNE_DAMAGE 
        @INVULNE_DAMAGE = true
      end
    }
  end
  #--------------------------------------------------------------------------
  # cache GOURMAN_DAMAGE
  #--------------------------------------------------------------------------
  def create_GOURMAN_DAMAGE_cache
    @GOURMAN_DAMAGE = false

    self.note.each_line { |line|
      case line
      when Lecode_Demi_DAMAGE::DemiDamage::Regexp::State::GOURMAN_DAMAGE 
        @GOURMAN_DAMAGE = true
      end
    }
  end
  ######################################################################
  #####################################################################
  #--------------------------------------------------------------------------
  # Si DEMI_DAMAGE
  #--------------------------------------------------------------------------
  def DEMI_DAMAGE?
    create_DEMI_DAMAGE_cache if @DEMI_DAMAGE == nil
    return @DEMI_DAMAGE
  end
  #--------------------------------------------------------------------------
  # Si QUART_DAMAGE
  #--------------------------------------------------------------------------
  def QUART_DAMAGE?
    create_QUART_DAMAGE_cache if @QUART_DAMAGE == nil
    return @QUART_DAMAGE
  end
  #--------------------------------------------------------------------------
  # Si VULNE_DAMAGE
  #--------------------------------------------------------------------------
  def VULNE_DAMAGE?
    create_VULNE_DAMAGE_cache if @VULNE_DAMAGE == nil
    return @VULNE_DAMAGE
  end
#--------------------------------------------------------------------------
  # Si INVLUNE_DAMAGE
  #--------------------------------------------------------------------------
  def INVULNE_DAMAGE?
    create_INVULNE_DAMAGE_cache if @INVULNE_DAMAGE == nil
    return @INVULNE_DAMAGE
  end
  #--------------------------------------------------------------------------
  # Si INVLUNE_DAMAGE
  #--------------------------------------------------------------------------
  def GOURMAN_DAMAGE?
    create_GOURMAN_DAMAGE_cache if @GOURMAN_DAMAGE == nil
    return @GOURMAN_DAMAGE
  end
end

#--------------------------------------------------------------------------


#=========================================================
class Game_Battler
  #--------------------------------------------------------------------------
  # Si DEMI_DAMAGE est appliquer dans un etat
  #--------------------------------------------------------------------------
  def DEMI_DAMAGE?
    self.states.each { |state|
      return true if state.DEMI_DAMAGE?
    }
    return false
  end
  #--------------------------------------------------------------------------
  # Si QUART_DAMAGE est appliquer dans un etat
  #--------------------------------------------------------------------------
  def QUART_DAMAGE?
    self.states.each { |state|
      return true if state.QUART_DAMAGE?
    }
    return false
  end
  #--------------------------------------------------------------------------
  # Si VULNE_DAMAGE est appliquer dans un etat
  #--------------------------------------------------------------------------
  def VULNE_DAMAGE?
    self.states.each { |state|
      return true if state.VULNE_DAMAGE?
    }
    return false
  end
  #--------------------------------------------------------------------------
  # Si INVULNE_DAMAGE est appliquer dans un etat
  #--------------------------------------------------------------------------
  def INVULNE_DAMAGE?
    self.states.each { |state|
      return true if state.INVULNE_DAMAGE?
    }
    return false
  end
    #--------------------------------------------------------------------------
  # Si GOURMAN_DAMAGE est appliquer dans un etat
  #--------------------------------------------------------------------------
  def GOURMAN_DAMAGE?
    self.states.each { |state|
      return true if state.GOURMAN_DAMAGE?
    }
    return false
  end
  #--------------------------------------------------------------------------
  # Execute les degats en fonction des condition
  #    user : The user of the damaging command
  #    @hp_damage, @mp_damage, @absorbed
  #--------------------------------------------------------------------------
  alias execute_damage_Lecode_Demi_DAMAGE_DemiDamage execute_damage
  def execute_damage(user)
    if DEMI_DAMAGE?
      @hp_damage = @hp_damage / 2
      @mp_damage = @mp_damage / 2
    end
   
      if QUART_DAMAGE?
      @hp_damage = @hp_damage / 3
      @mp_damage = @mp_damage / 3
    end
   
      if VULNE_DAMAGE?
      @hp_damage = @hp_damage * 2
      @mp_damage = @mp_damage
    end
   
    if INVULNE_DAMAGE?
      @hp_damage = 0
      @mp_damage = 0
    end
   
    if GOURMAN_DAMAGE?
    @absorbed = @hp_damage * 2
    end
   
    # Run original process
    execute_damage_Lecode_Demi_DAMAGE_DemiDamage(user)
  end
end