[VXACE] Barre en combat?

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  Modif pour les invocations et la limite
#==============================================================================

class Scene_Battle < Scene_Base
 #--------------------------------------------------------------------------
 # * Start processing
 #--------------------------------------------------------------------------
 alias limit_start start
 def start
   limit_start
   @i = 0 #Utile pour l'effet clignotement limite
 end
 #--------------------------------------------------------------------------
 # * Frame Update (incluant la limite)
 #--------------------------------------------------------------------------
 def update
   super
   update_basic(true)
   update_info_viewport                  # Update information viewport
   if $game_message.visible
     @info_viewport.visible = false
     @message_window.visible = true
   end
   unless $game_message.visible          # Unless displaying a message
     return if judge_win_loss            # Determine win/loss results
     update_scene_change
     if @target_enemy_window != nil
       update_target_enemy_selection     # Select target enemy
     elsif @target_actor_window != nil
       update_target_actor_selection     # Select target actor
     elsif @skill_window != nil
       update_skill_selection            # Select skill
     elsif @limit_window != nil
       update_limit_selection            ### Select limit ###
     elsif @invocation_window != nil
       update_invocation_selection            ### Select invocation ###
     elsif @item_window != nil
       update_item_selection             # Select item
     elsif @party_command_window.active
       update_party_command_selection    # Select party command
     elsif @actor_command_window.active
       update_actor_command_selection    # Select actor command
     else
       process_battle_event              # Battle event processing
       process_action                    # Battle action
       process_battle_event              # Battle event processing
     end
   end
 end
 #--------------------------------------------------------------------------
 # * Update Actor Command Selection (limite + invocation)
 #--------------------------------------------------------------------------
 def update_actor_command_selection
   # pour l'effet de couleur de l'affichage Limite dans les commandes
   if $limit_jauge[@active_battler.id] == 100
     @i+= 1
     if @i == LIMIT::TEMPO
      @actor_command_window.refresh
      @i = 0
   end
 end
 
   if Input.trigger?(Input::B)
     Sound.play_cancel
     prior_actor
   elsif Input.trigger?(Input::C)
     case @actor_command_window.index
     when 0  # Attack or limit ?
       Sound.play_cursor
       if $limit_jauge[@active_battler.id] == 100 # si jauge de limite pleine
         start_limit_selection
     else
       @active_battler.action.set_attack
       start_target_enemy_selection
     end
     when 1  # Skill
       if $enable_skill
       Sound.play_cursor
       start_skill_selection
     else
       Sound.play_buzzer
     end
     when 2  # Guard
       Sound.play_decision
       @active_battler.action.set_guard
       next_actor
     when 3  # Item
       Sound.play_cursor
       start_item_selection
     when 4 ### Invocation###
       if $enable_invocation
       Sound.play_cursor
       start_invocation_selection
     else
       Sound.play_buzzer
     end
     end
   end
 end
#--------------------------------------------------------------------------
 # * Start Limit Selection
 #--------------------------------------------------------------------------
 def start_limit_selection
   @help_window = Window_Help.new
   @limit_window = Window_Limit_Battle.new(272 - (196 / 2), 86, 196, 80, @active_battler)
   @limit_window.opacity = 0
   @limit_window.help_window = @help_window
   @actor_command_window.active = false
 end
 #--------------------------------------------------------------------------
 # * Update Limit Selection
 #--------------------------------------------------------------------------
 def update_limit_selection
   @limit_window.active = true
   @limit_window.update
   @help_window.update
   if Input.trigger?(Input::B)
     Sound.play_cancel
     end_skill_selection
   elsif Input.trigger?(Input::C)
     @skill = @limit_window.skill
     case @limit_window .index
     when 0 #utilisation limit
     if @skill != nil
       @active_battler.last_skill_id = @skill.id
     end
     if @active_battler.skill_can_use?(@skill)
       determine_skill
     else
       Sound.play_buzzer
     end
     when 1 #attaque normale
       Sound.play_cursor
       end_skill_selection
       @active_battler.action.set_attack
       start_target_enemy_selection
   end #case
   end
 end
 
 #--------------------------------------------------------------------------
 # * Start Invocation Selection
 #--------------------------------------------------------------------------
 def start_invocation_selection
   @help_window = Window_Help.new
   @invocation_window = Window_Invocation.new(136, 56, 272, 232, @active_battler)
   @invocation_window.opacity = 0
   update_back_sprite_item
   @invocation_window.help_window = @help_window
   @actor_command_window.active = false
 end
 #--------------------------------------------------------------------------
 # * Update Invocation Selection
 #--------------------------------------------------------------------------
 def update_invocation_selection
   @invocation_window.active = true
   @invocation_window.update
   @help_window.update
   if Input.trigger?(Input::B)
     Sound.play_cancel
     end_skill_selection
   elsif Input.trigger?(Input::C)
     @skill = @invocation_window.skill
     if @skill != nil
       @active_battler.last_skill_id = @skill.id
     end
     if @active_battler.skill_can_use?(@skill)
       determine_skill
     else
       Sound.play_buzzer
     end
   end
 end

 #--------------------------------------------------------------------------
 # * Confirm Skill / Limit / Invocation
 #--------------------------------------------------------------------------
 def determine_skill
   @active_battler.action.set_skill(@skill.id)
   if @limit_window != nil
   @limit_window.active = false
 end
   if @invocation_window != nil
   @invocation_window.active = false
 end
   if @skill_window != nil
   @skill_window.active = false
 end
   if @skill.need_selection?
     Sound.play_cursor
     if @skill.for_opponent?
       start_target_enemy_selection
     else
       start_target_actor_selection
     end
   else
     Sound.play_decision
     end_skill_selection
     next_actor
   end
 end
 
 #--------------------------------------------------------------------------
 # * End Skill + Limit Selection + Invocation Selection
 #--------------------------------------------------------------------------
 alias limit_end_skill_selection end_skill_selection
 def end_skill_selection
   if @limit_window != nil
     @limit_window.dispose
     @limit_window = nil
     @help_window.dispose
     @help_window = nil
   end
   if @invocation_window != nil
     @invocation_window.dispose
     @invocation_window = nil
     @help_window.dispose
     @help_window = nil
   end
   limit_end_skill_selection
 end
end

#==============================================================================
# ** Window_ActorCommand
#------------------------------------------------------------------------------
#  Ajout de Limite et Invocation
#==============================================================================

class Window_ActorCommand < Window_Command
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
   super(128, [], 1, 4)
   self.active = false
   @active_curseur = true
 end
 #--------------------------------------------------------------------------
 # * Setup
 #     actor : actor
 #--------------------------------------------------------------------------
 def setup(actor)
   if $limit_jauge[actor.id] == 100
   s1 = Vocab::Limit # Si jauge de limite pleine
   else
   s1 = Vocab::attack
 end
   s2 = Vocab::skill
   s3 = Vocab::guard
   s4 = Vocab::item
   s5 = "Invocation" # Ajout Invocation
   if actor.class.skill_name_valid     # Skill command name is valid?
     s2 = actor.class.skill_name       # Replace command name
   end
   @commands = [s1, s2, s3, s4,s5] #
   @item_max = 5 #
   self.index = 0
 # Pour griser les commandes inutiles
   self.draw_item(1, false)
   self.draw_item(4, false)
   $enable_skill = $enable_invocation = false
   for skill in actor.skills
     # on ne prend ni les limites ni les invocations
     unless skill.element_set.include?(LIMIT::ATTRIBUT_LIMIT) or skill.element_set.include?(MAT::ATTRIBUT_INVOCATION)
          $enable_skill = true
          break
   end
 end
 for skill in actor.skills
   if skill.element_set.include?(MAT::ATTRIBUT_INVOCATION)
     $enable_invocation = true
     break
   end
 end
 refresh
end
 #--------------------------------------------------------------------------
 # * Draw Item
 #     index   : item number
 #     enabled : enabled flag. When false, draw semi-transparently.
 #--------------------------------------------------------------------------
 def draw_item(index, enabled = true)
   rect = item_rect(index)
   rect.x += 4
   rect.width -= 8
   if @i == nil
     @i = 0
   end
   self.contents.clear_rect(rect)
   if @commands[index] == Vocab::Limit  and $game_temp.in_battle## Limit
     color = LIMIT::COULEURS[@i]
   self.contents.font.color = limit_color(color)
   @i += 1
   if @i == LIMIT::COULEURS.size
     @i = 0
   end
   else
   self.contents.font.color = normal_color
 end
 if $enable_skill == false and index == 1
   enabled = false
 end
 if $enable_invocation == false and index == 4
   enabled = false
 end
 
   self.contents.font.color.alpha = enabled ? 255 : 128
   self.contents.draw_text(rect, @commands[index])
 end
 #--------------------------------------------------------------------------
 # * Update cursor
 #--------------------------------------------------------------------------
 def update_cursor
   if @index < 0                   # If the cursor position is less than 0
     self.cursor_rect.empty        # Empty cursor
   else                            # If the cursor position is 0 or more
     row = @index / @column_max    # Get current row
     if row < top_row              # If before the currently displayed
       self.top_row = row          # Scroll up
     end
     if row > bottom_row           # If after the currently displayed
       self.bottom_row = row       # Scroll down
     end
     rect = item_rect(@index)      # Get rectangle of selected item
     rect.y -= self.oy             # Match rectangle to scroll position
     unless @active_curseur
     self.cursor_rect = rect       # Refresh cursor rectangle
   else
     self.cursor_rect.empty
     @curseur.x = rect.x + self.x - 6 -128 # -128 pour le deplacement dans le SBS
     @curseur.y = rect.y + self.y + 18 + 288 # + 288 pour le deplacement dans le SBS
   end
   end
 end
end
#==============================================================================
# ** Window_Skill
#------------------------------------------------------------------------------
#  This window displays a list of usable skills on the skill screen, etc.
#==============================================================================

class Window_Skill < Window_Selectable

 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   @data = []
   for skill in @actor.skills
     # on ne prend ni les limites ni les invocations
     unless skill.element_set.include?(LIMIT::ATTRIBUT_LIMIT) or skill.element_set.include?(MAT::ATTRIBUT_INVOCATION)
     @data.push(skill)
     if skill.id == @actor.last_skill_id
       self.index = @data.size - 1
     end
   end
 end
   @item_max = @data.size
   create_contents
   for i in 0...@item_max
     draw_item(i)
   end
 end
end

#==============================================================================
# ** module LIMIT
#------------------------------------------------------------------------------
#  C'est ici que l'on configure les options pour la Limit
#==============================================================================

module LIMIT
  #ID de l'attribut 'Limit' dans l'onglet systeme de la base de donnée
  ATTRIBUT_LIMIT = 17
  #
  SOUND_LIMIT = "FF7-Jauge_pleine" # Nom du fichier SE qd la jauge est pleine
 
 TEMPO = 6 ###Changez cette valeur pour la vitesse de clignotement Limit dans le Window_ActorCommand
 COULEURS= [14, 2, 10, 18, 10, 2] ##Choisissez les couleurs ici

end
#==============================================================================
# ** Sound
#------------------------------------------------------------------------------
#  This module plays sound effects. It obtains sound effects specified in the
# database from $data_system, and plays them.
#==============================================================================

module Sound

 # Materia
 def self.play_limit
   extension = [".wav", ".mp3", ".ogg"]
   for i in 0..extension.size
   existe = FileTest.exist?("Audio/SE/" + LIMIT::SOUND_LIMIT .to_s + extension[i].to_s)
       if existe == true
         break
       end
     end
   if existe == true
       Audio.se_play("Audio/SE/" + LIMIT::SOUND_LIMIT .to_s)
 else
       $data_system.sounds[1].play
     end
   end
 end
 
#==============================================================================
# ** Limit_Calcul
#==============================================================================
class Limit_Calcul

def initialize(actor, damage = 0)
 # s'il le perso a une limite mais qu'elle n'est pas configuré dans le menu
 # on prend la première
 if not $limit_use[actor.id].is_a?(RPG::Skill)
     for skill in actor.skills
     if skill.element_set.include?(LIMIT::ATTRIBUT_LIMIT)
   $limit_use[actor.id] = skill
   break
 end
end
end
# Si la jauge n'est pas encore pleine, si les damages sont > à 0
# et s'il existe une limite : on rempli la jauge en fonction des dégats
 if not $limit_jauge[actor.id] >= 100
 if damage > 0
   limit = $limit_use[actor.id]
   if limit.is_a?(RPG::Skill)
   # Dégat pour remplir la jauge Limit en fonction des hp max du héro (en %)
   j_max = 25 - $limit_vitesse[limit.id] #% des HPmax
   # Valeur jauge pleine en % (quand elle arrive à 100 c'est qu'elle est pleine)
   jauge_pleine = (actor.maxhp * j_max) /100
   x = (damage * 100) / jauge_pleine
   $limit_jauge[actor.id] += x
   if $limit_jauge[actor.id] >= 100
     $limit_jauge[actor.id] = 100
     Sound.play_limit
   end
 end
end
end
end
end

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

class Game_Battler
 
 #--------------------------------------------------------------------------
 # * Calculation of Damage From Normal Attack
 #     attacker : Attacker
 #    The results are substituted for @hp_damage
 #--------------------------------------------------------------------------
 alias limit_make_attack_damage_value make_attack_damage_value
 def make_attack_damage_value(attacker)
   limit_make_attack_damage_value(attacker)
   #augmentation LIMIT
   if not attacker.actor? and $limit_mode[self.id] == 0
     Limit_Calcul.new(self, @hp_damage)
   elsif attacker.actor? and $limit_mode[attacker.id] == 1
     Limit_Calcul.new(attacker, @hp_damage)
   end
 end
 #--------------------------------------------------------------------------
 # * Calculation of Damage Caused by Skills or Items
 #     user : User of skill or item
 #     obj  : Skill or item (for normal attacks, this is nil)
 #    The results are substituted for @hp_damage or @mp_damage.
 #--------------------------------------------------------------------------
 alias limit_make_obj_damage_value make_obj_damage_value
 def make_obj_damage_value(user, obj)
   limit_make_obj_damage_value(user, obj)
    # remet à 0 la jauge limit
   if obj.element_set.include?(LIMIT::ATTRIBUT_LIMIT)
     $limit_jauge[user.id] = 0
   end
 end
end

#==============================================================================
# ** Window_Limit_Battle
#------------------------------------------------------------------------------
#  This window displays a list of usable skills on the skill screen, etc.
#==============================================================================

class Window_Limit_Battle < Window_Selectable
 #--------------------------------------------------------------------------
 # * Object Initialization
 #     x      : window x-coordinate
 #     y      : window y-coordinate
 #     width  : window width
 #     height : window height
 #     actor  : actor
 #--------------------------------------------------------------------------
 def initialize(x, y, width, height, actor)
   super(x, y, width, height)
   @actor = actor
   @column_max = 1
   @active_curseur = true
   self.index = 0
   refresh
 end
 #--------------------------------------------------------------------------
 # * Get Skill
 #--------------------------------------------------------------------------
 def skill
   return @limit
 end
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   @limit = $limit_use[@actor.id]
   if @limit.is_a?(RPG::Skill)
   create_contents
   rect = item_rect(0)
   self.contents.clear_rect(rect)
   skill = @limit
   if skill != nil
     rect.width -= 4
     enabled = @actor.skill_can_use?(skill)
     draw_item_name(skill, rect.x, rect.y, enabled)
   end
 #  rect = item_rect(1)
 #  self.contents.clear_rect(rect)
 #  self.contents.draw_text(rect, "Attaque")
 #  @item_max = 2
 end
end
 #--------------------------------------------------------------------------
 # * Update Help Text
 #--------------------------------------------------------------------------
 def update_help
   if self.index == 0
   @help_window.set_text(skill == nil ? "" : skill.description)
 else
   @help_window.set_text("Utilise l'attaque classique")
 end
 end
end
#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  Ajout de la jauge limite + remise à 0 si mort
#==============================================================================

class Window_BattleStatus < Window_Selectable
 #--------------------------------------------------------------------------
 # * Draw Item
 #     index : Item number
 #--------------------------------------------------------------------------
 alias limit_draw_item draw_item
 def draw_item(index)
   limit_draw_item(index)
   rect = item_rect(index)
   actor = $game_party.members[index]
   if actor.dead?
     $limit_jauge[actor.id] = 0 # remet à 0 la jauge limit
   end
   draw_actor_limit(actor, 90, rect.y, 70)
 end
end

Code:

class Window_BattleStatus < Window_Selectable
  def draw_gauge_area_with_tp(rect, actor)
    draw_actor_hp(actor, rect.x + 82, rect.y, 64)
    draw_actor_mp(actor, rect.x + 156, rect.y, 64)
    draw_actor_tp(actor, rect.x + 0, rect.y, 72)
  end
end

Code:

class Game_Battler < Game_BattlerBase  
  def init_tp
    self.tp = rand * 0
  end
end