Envision, Create, Share

Welcome to HBGames, a leading amateur game development forum and Discord server. All are welcome, and amongst our ranks you will find experts in their field from all aspects of video game design and development.
Register

Help me make the bar please!

Latest Post

JoshieBoy

Member

46
Alright, I am using Nicks Tactical battle system, http://www.creationasylum.net/index.php?showtopic=14331, and Dervvvulfmans limit break system:

Code: 
#==============================================================================
# ** Limit Break (DVV's)
#------------------------------------------------------------------------------
#    by DerVVulfman
#    version 2.3
#    07-05-2007
#    Full SDK 2.2 Compatible (Does not need or require SDK 2.2)
#------------------------------------------------------------------------------
#
# INTRODUCTION:
#
#   This system is a revamped & rewritten system that disables 'element-tagged'
#   skills until the hero's limitbreak bar is filled.   Once the skill is used,
#   the skill becomes disabled again.   Works with and without the RTAB system.
#   
#   One feature  that was sadly lacking in all other systems  was the inability
#   to fill the limitbreak bar with item damage.   Previous systems only looked
#   to damage inflicted through attacks and skill use.   Items such as grenades
#   were entirely overlooked.
#
#   It has been designed 'menu-less' by intent, and this is to prevent any pos-
#   sible conflicts with any custom menu system. However Alistor (RMXP.ORG) has
#   designed a menu system  that can change  an actor's  limit break fill-type:
#   (Attack/Defend/Guard).  It is ready for plug-n-play use.
#
#   The system, by itself, does not change the 'ATTACK' option  in the Actor's
#   command window either.   Instead, this system  enables/disables the skills
#   in the skill menu  for you to select.   Another add-on has been created by
#   me to change the 'Attack' option for you.      * It's been asked for. :) *
#
#   It still requires a bar-drawing system such as 'Cogwheel's HP/SP/EXP Gauge' 
#   script to draw the Limit Break bar, unless a suitable Bar Drawing script is
#   available.  However, when not using a bar-drawing system, you merely do not
#   have bars visible in-game.  Previous versions either had their own built-in
#   cheaply designed bar system,  or required a separate script  to prevent the 
#   project from crashing.   This system neither needs bars  to be drawn or re-
#   quires a bar system to prevent crashes.
#
#------------------------------------------------------------------------------
#
#  SYSTEMS OF NOTE:
#
#   While most of the configuration system is set via CONSTANTS,  the 'Flexible
#   Positioning System' is set via ($)Global values that can be edited from any
#   MAP EVENT script call.   That way,  positioning of the bars  can be changed
#   based on which menu or battlestatus window you are using at the time.   The
#   RTAB battlesystem  uses its own set of $Global values ($lb_rtab_pos & _var)
#   as it has an almost unique way  to draw its own  BattleStatus window.   The
#   ParaDog v 2.58 battlesystem  also uses  these two values  for its own limit
#   break bar placement.
#
#   The $lb_hidden global array can hold the ID of actors in your database that
#   do not have their Limit Break bars visible on the screen.  It also disables
#   the Limit Break Sound Effect from playing if the same actor's 'limit-break' 
#   value has maxed out (his/her non-visible bar becomes filled).  As a $global
#   value, it too can be edited from any MAP EVENT script call.
#
#------------------------------------------------------------------------------
#
#  COMPATABILITY:
#
#   This system has been designed initially for the default and RTAB battlesys-
#   tems, however by the use of ALIASes throughout the system... this script is
#   also SDK 2.2 compliant, and compliant with both the XRXS #65 and the Para-
#   Dog V 2.58 battlesystem:
#
#   RE:  ParaDog's V 2.58
#   *  As stated above, the ParaDog system also uses the same section of the
#      'Flexible Positioning System as RTAB.   This allows the use of Verti-
#      cally aligned Limit Break bars instead of the default Horizontal bars.
#
#
#------------------------------------------------------------------------------
#
#  CREDITS AND THANKS:
#
#   Thanks goes to link2795 for discovering the 'healing items/RTAB' bug.  And
#   to Jaide for recommending the 'Death Wipe' feature, & finding an RTAB bug.
#
#==============================================================================


   #=======================================================================#
   #  **  C  O  N  F  I  G  U  R  A  T  I  O  N      S  Y  S  T  E  M  **  #
   #=======================================================================#

  # Name of the Limit Break element 
  LB_NAME   = "Limit Break"


  # Starting/Default Limit Break Setting
  LB_START  = 0   # 0 = Attack          |  1 = Critical      |  2 = Damaged
                  # 3 = Killed an enemy |  4 = Killed a Boss |  5 = Hero Died
                  # 6 = Victory         |  7 = Escape/Flee   |  8 = Defending
                  # 9 = Lone Combatant  | 10 = Any Action    | 11 = Crit. Health
  

  # Enemy Bosses (by ID)
  # Related to the LB_Rate, it determines if points garnered through 'killing'
  # an ememy gives regular 'enemy' points or 'boss' points to your LB gauge.
  LB_BOSSES = [17]   # Set to enemy 17 (Skeleton)
  
  # Hidden Actors (by ID)
  # This array holds the ID number of Actors who hide their own Limit Break bars
  # in both the battle and menu screens.  Will only apply to both battle & menu.
  $lb_hidden = [7]  # Set to actor #7: Gloria
  
 
  # Limit Break Max Value
  LB_MAX    = 1000

  
  # Limit Break Fill Rates
  # For flat rates & max value settings, the max value should not exceed LB_MAX.
  LB_RATE   = [  10,   50,  200,  # Hero Attacks the Enemy    (rate, min., max.)
                 25,   25, 1000,  # Hero delivers a CRITICAL! (rate, min., max.)
                 30,    1, 1000,  # Hero takes Damage         (rate, min., max.)
                500,  750,  900,  # Fatalaties:  Enemy, Boss or Self (flat rate)
                200,  200,  100,  # Victory, Escape & Defending      (flat rate)
                160,   40,  160]  # Loner, Action & Crit. Health     (flat rate)

  # Limit Break Death Wipe                
  # This supercedes the LB_RATE condition for the 'Hero Died' setting.
  LB_D_WIPE = true                # If true, death wipes out their LB points.
                
  
  # Flexible positioning system.  Default position appears under the STATUS txt.
  $lb_menu_on    = 1              # If set to '1', the bar is shown in the menu.
  $lb_menu_pos   = [ 0,   0, 190] # Positioning in the menu:  X, Y, & bar width.
  $lb_battle_pos = [ 0,  64, 120] # Positioning in the battle menu.  Same setup.
  
  # For special consideration...  # RTAB and ParaDog Limit break bars use below.
  
  $lb_rtab_pos   = [ 0, -25, 111] # Position if using RTAB system.   Same setup.
  $lb_rtab_var   = [0, 40]        # Variable distances between hero's LB gauges.
  
  
  # SE played when Limit Break filled
  LB_RING   = "006-System06"
    

#------------------------------------------------------------------------------#
# Do not edit below unless you know what you're doing.  The following code is  #
# for automatic systems in the script.  Values are edited or passed elsewhere. #
#------------------------------------------------------------------------------#

  # Stores the battler id for item users (needed for non-RTAB systems)
  $item_user = nil
  # Obtain the Limit Break 'id' from the system
  $data_system = load_data("Data/System.rxdata")
  $lb_element_id = $data_system.elements.index(LB_NAME)
  
   #========================================================================
   #            C O N F I G U R A T I O N   S Y S T E M   E N D            #
   #========================================================================


module Limit_Shortcuts
  #--------------------------------------------------------------------------
  # * Attack / Struck an enemy (for type 0 conditions)
  #     aggressor : battler
  #     victim    : battler
  #--------------------------------------------------------------------------  
  def lb_attacker(aggressor, victim, current_dmg)
    # Check to make sure the victim is an enemy and the aggressor is self
    if aggressor.is_a?(Game_Actor) && victim.is_a?(Game_Enemy) && aggressor.lb_type == 0
      # Limit Break growth calculation
      lb_calc = current_dmg * LB_RATE[0] * 10 / victim.base_damage
      # Adjust Limit Break growth between min & max values
      lb_add = [[lb_calc, LB_RATE[1]].max, LB_RATE[2]].min
      # OD gauge increase
      aggressor.limitbreak += lb_add
    end  
  end
  #--------------------------------------------------------------------------
  # * Damaged by an enemy (for type 2 conditions)
  #     aggressor : battler
  #     victim    : battler
  #--------------------------------------------------------------------------  
  def lb_damaged(aggressor, victim, current_dmg)
    # Check to make sure the agressor is an enemy and the victim is self
    if aggressor.is_a?(Game_Enemy) && victim.is_a?(Game_Actor) && victim.lb_type == 2
      lb_calc = current_dmg * LB_RATE[6] * 10 / victim.maxhp
      # Adjust Limit Break growth between min & max values
      lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
      victim.limitbreak += lb_add
    end    
  end
end

#============================================================================== 
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles data surrounding the system. Backround music, etc.
#  is managed here as well. Refer to "$game_system" for the instance of 
#  this class.
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  # Additional values for the save/load feature
  attr_accessor :lb_rtab_detected         # Detect RTAB system
  attr_accessor :lb_para_detected         # Detect ParaDog system
  attr_accessor :lb_mn                    # menu on
  attr_accessor :lb_mp                    # menu position
  attr_accessor :lb_bp                    # battle position
  attr_accessor :lb_rp                    # rtab position
  attr_accessor :lb_rv                    # rtab variance
  attr_accessor :lb_h                     # hidden
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias lb_init initialize
  def initialize
    # Perform the original call
    lb_init
    @lb_rtab_detected = nil
    @lb_para_detected = nil
    # Create the savable values
    @lb_mn            = 0
    @lb_mp            = []
    @lb_bp            = []
    @lb_rp            = []
    @lb_rv            = []
    @lb_h             = []
  end  
end  



#==============================================================================
# ** Scene_Save
#------------------------------------------------------------------------------
#  This class performs save screen processing.
#==============================================================================

class Scene_Save < Scene_File
  #--------------------------------------------------------------------------
  # * Write Save Data
  #     file : write file object (opened)
  #--------------------------------------------------------------------------
  alias lb_wsd write_save_data
  def write_save_data(file)
    # Store the globals
    $game_system.lb_mn  = $lb_menu_on
    $game_system.lb_mp  = $lb_menu_pos
    $game_system.lb_bp  = $lb_battle_pos
    $game_system.lb_rp  = $lb_rtab_pos
    $game_system.lb_rv  = $lb_rtab_var
    $game_system.lb_h   = $lb_hidden
    # Perform the original call
    lb_wsd(file)
  end
end



#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
#  This class performs load screen processing.
#==============================================================================

class Scene_Load < Scene_File
  #--------------------------------------------------------------------------
  # * Read Save Data
  #     file : file object for reading (opened)
  #--------------------------------------------------------------------------
  alias lb_rsd read_save_data
  def read_save_data(file)
    #Perform the original call
    lb_rsd(file)
    # ReStore the globals
    $lb_menu_on    = $game_system.lb_mn
    $lb_menu_pos   = $game_system.lb_mp
    $lb_battle_pos = $game_system.lb_bp
    $lb_rtab_pos   = $game_system.lb_rp
    $lb_rtab_var   = $game_system.lb_rv
    $lb_hidden     = $game_system.lb_h
  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
  include Limit_Shortcuts
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :max_ct
  attr_accessor :base_damage
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias lb_init initialize
  def initialize
    lb_init
    if max_ct != nil
      $game_system.lb_para_detected = true
    end
  end
  #--------------------------------------------------------------------------
  # * Applying Normal Attack Effects (Edited)
  #     attacker : battler
  #--------------------------------------------------------------------------
  alias lb_attack_effect attack_effect
  def attack_effect(attacker)
    # Attach base damage to battler (for self.base_damage)
    @base_damage = nil
    # Execute the original process
    result = lb_attack_effect(attacker)
    # Set current damage (rtab or not)
    current_dmg = self.damage
    if $game_system.lb_rtab_detected; current_dmg = self.damage[attacker]; end
    # Set crit flag (rtab or not)
    current_crit = self.critical
    if $game_system.lb_rtab_detected; current_crit = self.critical[attacker]; end
    # Calculate basic damage
    if @base_damage == nil
      @base_damage = 
      [attacker.atk - self.pdef / 2, 0].max * (20 + attacker.str) / 20
    end
    # When actual physical damage is applied
    if result && current_dmg.is_a?(Numeric) && self.base_damage > 0
      # When HERO attacking the enemy (and tagged for 'Attack')
      lb_attacker(attacker, self, current_dmg)
      # If the HERO made a critical hit on the Enemy
      if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && attacker.lb_type == 1 
        if current_crit
          # Limit Break growth calculation
          lb_calc = current_dmg * LB_RATE[3] * 10 / self.base_damage
          # Adjust Limit Break growth between min & max values
          lb_add = [[lb_calc, LB_RATE[4]].max, LB_RATE[5]].min
          # OD gauge increase
          attacker.limitbreak += lb_add  
        end
      end
      # When HERO is damaged by the enemy (and tagged for 'Damaged')
      lb_damaged(attacker, self, current_dmg)
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Apply Skill Effects
  #     user  : the one using skills (battler)
  #     skill : skill
  #--------------------------------------------------------------------------  
  alias lb_skill_effect skill_effect  
  def skill_effect(user, skill)
    # Attach base damage to battler (for self.base_damage)
    @base_damage = nil
    # Execute the original process
    result = lb_skill_effect(user, skill)
    # Set current damage (rtab or not)
    current_dmg = self.damage
    if $game_system.lb_rtab_detected; current_dmg = self.damage[user]; end
    # Recalculate the base (unadjusted) damage
    if @base_damage == nil
      # Calculate power
      power = skill.power + user.atk * skill.atk_f / 100
      if power > 0
        power -= self.pdef * skill.pdef_f / 200
        power -= self.mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      # Calculate rate
      rate = 20
      rate += (user.str * skill.str_f / 100)
      rate += (user.dex * skill.dex_f / 100)
      rate += (user.agi * skill.agi_f / 100)
      rate += (user.int * skill.int_f / 100)
      # Calculate basic damage
      @base_damage = power * rate / 20
    end
    # When actual physical damage is applied
    if result && current_dmg.is_a?(Numeric) && self.base_damage > 0
      # When HERO attacking the enemy (and tagged for 'Attack')
      lb_attacker(user, self, current_dmg)
      # When HERO is damaged by the enemy (and tagged for 'Damaged')
      lb_damaged(user, self, current_dmg)
    end
    # When limitbreak skill is used
    if user.is_a?(Game_Actor) && skill.element_set.include?($lb_element_id)
      # Reset gauge
      user.limitbreak = 0
    end
    return result
  end
  #--------------------------------------------------------------------------
  # * Application of Item Effects
  #     item : item
  #--------------------------------------------------------------------------
  alias lb_item_effect item_effect  
  def item_effect(item, battler = @active_battler)
    # Attach base damage to battler (for self.base_damage)
    @base_damage = nil
    # Set 'user' to the current battler (and ensure if RTAB)
    user = $item_user
    if $game_system.lb_rtab_detected; user = battler; end
    # Execute the original process (RTAB or not)
    if $game_system.lb_rtab_detected
      result = lb_item_effect(item, user)
    else
      result = lb_item_effect(item)
    end
    # Set current damage (rtab or not)
    current_dmg = self.damage
    if $game_system.lb_rtab_detected; current_dmg = self.damage[user]; end
    # Recalculate the base (unadjusted) damage
    if @base_damage == nil
      #Calculate power
      power = maxhp * item.recover_hp_rate / 100 + item.recover_hp
      if power < 0
        power += self.pdef * item.pdef_f / 20
        power = [power, 0].min
      end
      # Set damage value and reverse item power amount
      @base_damage = -power
    end
    # When actual physical damage is applied
    if result && current_dmg.is_a?(Numeric) && self.base_damage > 0
      # When HERO attacking the enemy (and tagged for 'Attack')
      lb_attacker(user, self, current_dmg)
      # When HERO is damaged by the enemy (and tagged for 'Damaged')
      lb_damaged(user, self, current_dmg)
    end
    return result
  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 < Game_Battler 
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader   :limitbreak               # Limitbreak value
  attr_accessor :lb_type                  # Limitbreak action type
  attr_accessor :limitbreak_ring          # Limit Break Ring Checker
  attr_accessor :battle_started
  #--------------------------------------------------------------------------
  # * Setup
  #     actor_id : actor ID
  #--------------------------------------------------------------------------
  alias lb_setup setup
  def setup(actor_id)
    # Perform the original call
    lb_setup(actor_id)
    @limitbreak = 0           # Reset Limit Break gauge to zero
    @lb_type = LB_START       # Set the Limit Break type to 'config' settings.
    @limitbreak_ring = false  # Turn the 'ring' off
    @battle_started  = false
  end
  #--------------------------------------------------------------------------
  # * Determine if Skill can be Used
  #     skill_id : skill ID
  #--------------------------------------------------------------------------
  alias lb_skill_can_use? skill_can_use?
  def skill_can_use?(skill_id)
    # Get result from original call
    result = lb_skill_can_use?(skill_id)
    # Return if already disabled
    return if result == false
    # Obtain skill from database
    skill = $data_skills[skill_id]
    # Only perform if skill
    if skill != nil
      # Only perform if includes the Element
      if skill.element_set.include?($lb_element_id)
        # If the limitbreak bar is filled, skill is available
        if self.limitbreak == LB_MAX
          result = true
        # Otherwise, it isn't
        else
          result = false
        end
      end
    end
    return result & super
  end 
  #--------------------------------------------------------------------------
  # * Adjust the limitbreak value (permits addition & keeps within range)
  #--------------------------------------------------------------------------
  def limitbreak=(limitbreak)
    @limitbreak = limitbreak
    @limitbreak = LB_MAX if @limitbreak > LB_MAX 
    @limitbreak = 0 if @limitbreak < 0
  end
  #--------------------------------------------------------------------------
  # * Acquire Limit Break value (nil values won't cause errors now)
  #--------------------------------------------------------------------------
  def limitbreak
    # Return 0 if nil (prevent errors)
    @limitbreak = 0 if @limitbreak == nil
    return @limitbreak
  end
end



#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================
class Window_Base
  #--------------------------------------------------------------------------
  # * Draw Actor Name
  #--------------------------------------------------------------------------
  alias lb_draw_actor_name draw_actor_name
  def draw_actor_name(actor, x, y)
    # Only perform if the actor isn't hidden
    unless $lb_hidden.include?(actor.id)
      # Set/reset the x, y and width of the Limit Break bar.    
      ox = $game_temp.in_battle ? $lb_battle_pos[0] : $lb_menu_pos[0]
      oy = $game_temp.in_battle ? $lb_battle_pos[1] : $lb_menu_pos[1]
      ow = $game_temp.in_battle ? $lb_battle_pos[2] : $lb_menu_pos[2]
      # To menu... or not to menu
      if $lb_menu_on == 1 && !$game_temp.in_battle
        draw_actor_lb(actor, x + ox, y + oy + 32, ow)
      elsif $game_temp.in_battle
        unless $game_system.lb_rtab_detected or $game_system.lb_para_detected
          draw_actor_lb(actor, x + ox, y + oy + 32, ow)
        end
      end
    end
    lb_draw_actor_name(actor, x, y)
  end  
  #--------------------------------------------------------------------------
  # * Draw Battler Name
  #--------------------------------------------------------------------------
  # If the BattleStatus value of 'Alignment' exists
  if $bstat_align != nil
    alias lb_draw_battler_name draw_battler_name
    def draw_battler_name(actor, x, y)
      # Only perform if the actor isn't hidden
      unless $lb_hidden.include?(actor.id)
        # Set/reset the x, y and width of the Limit Break bar.    
        ox = $game_temp.in_battle ? $lb_battle_pos[0] : $lb_menu_pos[0]
        oy = $game_temp.in_battle ? $lb_battle_pos[1] : $lb_menu_pos[1]
        ow = $game_temp.in_battle ? $lb_battle_pos[2] : $lb_menu_pos[2]
        # To menu... or not to menu
        if $lb_menu_on == 1 && !$game_temp.in_battle
          draw_actor_lb(actor, x + ox, y + oy + 32, ow)
        elsif $game_temp.in_battle
          unless $game_system.lb_rtab_detected or $game_system.lb_para_detected
            draw_actor_lb(actor, x + ox, y + oy + 32, ow)
          end
        end
      end
      lb_draw_battler_name(actor, x, y)
    end    
  end
  #--------------------------------------------------------------------------
  # * Draw Limit Break Meter
  #--------------------------------------------------------------------------
  def draw_actor_lb(actor, x, y, width = 144)
    if defined?(gauge_rect)
      rate = actor.limitbreak.to_f / LB_MAX
      plus_x = 0
      rate_x = 0
      plus_y = 25
      plus_width = 0
      rate_width = 100
      height = 10
      align1 = 1
      align2 = 2
      align3 = 0
      grade1 = 1
      grade2 = 0
      color1 = Color.new(0, 0, 0, 192)
      color2 = Color.new(255, 255, 192, 192)
      color3 = Color.new(0, 0, 0, 192)
      color4 = Color.new(64, 0, 0, 192)
      color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
      color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
      lb = (width + plus_width) * actor.limitbreak * rate_width / 100 / LB_MAX
      gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
        width, plus_width + width * rate_width / 100,
        height, lb, align1, align2, align3,
        color1, color2, color3, color4, color5, color6, grade1, grade2)
    end      
  end
end



#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
#  This window displays the status of all party members on the battle screen.
#==============================================================================
class Window_BattleStatus < Window_Base
  
  alias lb_init initialize
  def initialize
    lb_init
    if defined?(at_refresh)
      $game_system.lb_rtab_detected = true
    end
    refresh
  end
  #--------------------------------------------------------------------------
  # * Full Limit Break Gauge SE
  #--------------------------------------------------------------------------
  def full_lb_se
    if LB_RING != nil
      if LB_RING != ""
        Audio.se_play("Audio/SE/" + LB_RING, 80, 100)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame renewal
  #--------------------------------------------------------------------------
  alias lb_refresh refresh
  def refresh(number = 0)
    # Call the original def
    if $game_system.lb_rtab_detected
      lb_refresh(number)
    else
      lb_refresh
    end
    # This block is needed only if RTAB in use
    if $game_system.lb_rtab_detected or $game_system.lb_para_detected
      # Ensure bitmap available for bar drawing
      if self.contents == nil
        self.contents = Bitmap.new(width - 32 ,height - 32)
      end
      # Search through actors & draw bar if applicable
      if number == 0
        for i in 0...$game_party.actors.size
          rtab_pos_x = $lb_rtab_pos[0] + ($lb_rtab_var[0] * i)
          rtab_pos_y = $lb_rtab_pos[1] + ($lb_rtab_var[1] * i)
          unless $lb_hidden.include?($game_party.actors[i].id)
            draw_actor_lb($game_party.actors[i], rtab_pos_x, rtab_pos_y+10,  $lb_rtab_pos[2])
          end
        end
      else
        if $game_party.actors[number].is_a?(Game_Actor)
          rtab_pos_x = $lb_rtab_pos[0] + ($lb_rtab_var[0] * number)
          rtab_pos_y = $lb_rtab_pos[1] + ($lb_rtab_var[1] * number)
          unless $lb_hidden.include?($game_party.actors[number].id)
            draw_actor_lb($game_party.actors[number], rtab_pos_x, rtab_pos_y+10, $lb_rtab_pos[2])
          end
        end
      end
    end
    # Go through the Actors
    $game_party.actors.each { |actor|
      # Only perform if the actor exists
      next unless actor.exist?
      # When the Limit Break gauge is set to zero,
      # Reset the Limit Break Ringer to false
      if actor.limitbreak == 0
        actor.limitbreak_ring = false
      end
      # When the Limit Break Ringer hasn't rung
      if actor.limitbreak_ring == false
        # But, if the Limit Break Bar is filled
        if actor.limitbreak == LB_MAX
          # Do not permit hidden actor bars to ring
          unless $lb_hidden.include?(actor.id)
            # If the battle only just started
            if actor.battle_started == true
              # turn off the battle started flag
              actor.battle_started = false
            else
              # Play the Limit Break Sound Effect
              full_lb_se
            end
          end
          # And Set the Limit Break Ringer to true
          actor.limitbreak_ring = true
        end
      end
      }        
  end
end



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

class Scene_Battle
  #--------------------------------------------------------------------------
  # * Main Processing
  #--------------------------------------------------------------------------
  alias lb_main main
  def main  
    # Ensure that the limitbreak SE doesn't chime at battle start
    for i in 0...$game_party.actors.size
      if $game_party.actors[i].limitbreak == LB_MAX
        $game_party.actors[i].battle_started  = true
        $game_party.actors[i].limitbreak_ring = true
      end
    end
    lb_main
  end
  #--------------------------------------------------------------------------
  # * Battle Ends
  #     result : results (0:win 1:lose 2:escape)
  #--------------------------------------------------------------------------
  alias lb_battle_end battle_end
  def battle_end(result)
    # Branch on Battle condition
    case result
    when 0 # Victory
      $game_party.actors.each { |actor|
      next unless actor.exist?
      # For each actor who won & set to Victory
      if actor.lb_type == 6
        actor.limitbreak += LB_RATE[12]
      end
      }
    when 1 # Escape
      $game_party.actors.each { |actor|
      next unless actor.exist?
      # For each actor who ran & set to Escape
      if actor.lb_type == 7
        actor.limitbreak += LB_RATE[13]
      end
      }
    end
    # Defeat
    lb_battle_end(result)
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 2 : start action)
  #--------------------------------------------------------------------------
  alias lb_adddate_p4_s2 update_phase4_step2
  def update_phase4_step2(battler = @active_battler)
    # Perform only if actor
    if battler.is_a?(Game_Actor)
      # Reset adding value
      lb_add = 0
      # Branch on LimitBreak type
      case battler.lb_type
      when 8 # When Defending
        if battler.current_action.kind = 0
          if battler.current_action.basic == 1
            lb_add = LB_RATE[14]
            print lb_add
          end
        end
      when 9 # When it's a lone battler
        if $game_party.actors.size == 1
          lb_add = LB_RATE[15]
        end
      when 10 # When performing ANY acton
        lb_add = LB_RATE[16]
      when 11 # If in CRITICAL
        if battler.hp <= @active_battler.maxhp / 4
          lb_add = LB_RATE[17]
        end
      end
      # Add values to limitbreak
      battler.limitbreak += lb_add
    end
    # Perform the original call
    if $game_system.lb_rtab_detected; lb_adddate_p4_s2(battler); else; lb_adddate_p4_s2; end
  end
  #--------------------------------------------------------------------------
  # * Make Item Action Results
  #--------------------------------------------------------------------------  
  alias lb_miar make_item_action_result 
  def make_item_action_result(battler = @active_battler)
    $item_user = battler
    # Perform the original call
    if $game_system.lb_rtab_detected; lb_miar(battler); else; lb_miar; end
  end  
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 4 : animation for target)
  #--------------------------------------------------------------------------  
  alias lb_update_p4_s4 update_phase4_step4 
  def update_phase4_step4(battler = @active_battler)
     if $game_system.lb_rtab_detected
      @status_window.update
      @status_window.refresh
     end
    # Perform the original call
    if $game_system.lb_rtab_detected; lb_update_p4_s4(battler); else lb_update_p4_s4 ; end    
  end
  #--------------------------------------------------------------------------
  # * Frame Update (main phase step 6 : refresh)
  #--------------------------------------------------------------------------
  alias lb_up4s6 update_phase4_step6
  def update_phase4_step6(battler=@active_battler)
    @rtab = !@target_battlers
    for target in (@rtab ? battler.target : @target_battlers)
      # If a battler has died
      if target.dead?
        # If the battler is an enemy
        if target.is_a?(Game_Enemy)
          # If an enemy killed check is performed
          if battler.lb_type == 3
            battler.limitbreak += LB_RATE[9]
          # If a boss enemy check is performed
          elsif battler.lb_type == 4
            if LB_BOSSES.include?(target.id)
              battler.limitbreak += LB_RATE[10]
            end
          end
        # else the battler is an actor
        else
          # if a 'Hero Dies' check is performed
          if target.lb_type == 5
            target.limitbreak += LB_RATE[11]
          end
          # If the Limit Break Death Wipe feature is on
          if LB_D_WIPE
            target.limitbreak = 0
          end
        end
        if $game_system.lb_rtab_detected
           @status_window.update
           @status_window.refresh
        end        
      end
    end    
    @rtab ? lb_up4s6(battler) : lb_up4s6
  end  
end

I wanted to know if there was a way to make a limit gauge bar show up here:

http://i189.photobucket.com/albums/z32/ ... nshot1.jpg[/img]

Right below the hp and sp bars would be perfect.
 
Sort by date Sort by votes
Brewmeister

Brewmeister

Sponsor

742
Hey there,

I've never played FF, so I just learned what a limit break was. :scruff:

I was able to get the bar to show up, using Clive's LB Bar.

The scripts are in the order:

<default scripts>
<all of the TBS scripts>
DVV_Limit_Break
Clive_LB_Bar
main

Here's the LB Bar script:

Code: 
#===========================================================================
# *** HP/MP/ATB/LimitBreak bar Slanted Style Compatible with RTAB ***
# *** Version 2.1
#---------------------------------------------------------------------------
# by Clive 
# based on Cogwheel's Bars and Sephiroth Spawn's Slanted Bars.
#---------------------------------------------------------------------------
# ----- GREAT THANKS to DerVVulfman for solving the lag problem
#------This is a plug and play script so it should work without any problem!
#=============================================================================

# If using with Limit Break, must paste BELOW the Limit Break script as it re-
# writes the 'Gauge drawing' system.  Will cause an error if not properly put.

# If used with Trickster's STEAL SCRIPT version 6 R1 (revision 1), then the
# height of RTAB's AT Bar (Draw Actor ATG) may not be smaller than 5 pixels 
# due to a float-to-float error.  A height of 6 pixels is the smallest.


#==============================================================================
# ** 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 < Game_Battler
  #--------------------------------------------------------------------------
  # * Get the current EXP
  #--------------------------------------------------------------------------
  def now_exp
    return @exp - @exp_list[@level]
  end
  #--------------------------------------------------------------------------
  # * Get the next level's EXP
  #--------------------------------------------------------------------------
  def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
  end
end


#==============================================================================
# ** Window_Base 
#------------------------------------------------------------------------------
#  This class is for all in-game windows.
#==============================================================================

class Window_Base < Window  
  
  #==========================================================================
  # * Draw Slant Bar(by SephirothSpawn)
  #==========================================================================
  def draw_slant_bar(x, y, min, max, width = 152, height = 6,
      bar_color = Color.new(150, 0, 0, 255),
      end_color = Color.new(255, 255, 60, 255))
    # Draw Border
    for i in 0..height
      self.contents.fill_rect(x + i, y + height - i, width + 1, 1, Color.new(50, 50, 50, 255))
    end
    # Draw Background
    for i in 1..(height - 1)
      r = 100 * (height - i) / height + 0 * i / height
      g = 100 * (height - i) / height + 0 * i / height
      b = 100 * (height - i) / height + 0 * i / height
      a = 255 * (height - i) / height + 255 * i / height
      self.contents.fill_rect(x + i, y + height - i, width, 1, Color.new(r, b, g, a))
    end
    # Draws Bar
    for i in 1..( (min.to_f / max.to_f) * width - 1)
      for j in 1..(height - 1)
        r = bar_color.red * (width - i) / width + end_color.red * i / width
        g = bar_color.green * (width - i) / width + end_color.green * i / width
        b = bar_color.blue * (width - i) / width + end_color.blue * i / width
        a = bar_color.alpha * (width - i) / width + end_color.alpha * i / width
        self.contents.fill_rect(x + i + j, y + height - j, 1, 1, Color.new(r, g, b, a))
      end
    end
  end
  
  #==========================================================================
  # * Draw HP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #==========================================================================
  alias :draw_actor_hp_hpsp :draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)   
    draw_slant_bar(x, y + 12, actor.hp, actor.maxhp, width, 6, 
      bar_color = Color.new(150, 0, 0, 255), 
      end_color = Color.new(255, 255, 60, 255))
    draw_actor_hp_hpsp(actor, x, y, width)
   end
  #==========================================================================
  # * Draw SP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #==========================================================================
  alias :draw_actor_sp_hpsp :draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    draw_slant_bar(x, y + 12, actor.sp, actor.maxsp, width, 6,
      bar_color = Color.new(0, 0, 155, 255), 
      end_color = Color.new(255, 255, 255, 255))
    draw_actor_sp_hpsp(actor, x, y, width)
  end
  #==========================================================================
  # * Draw EXP
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #==========================================================================
  alias raz_bars_base_exp draw_actor_exp  
  def draw_actor_exp(actor, x, y)
    if actor.level == 99
      draw_slant_bar(x, y + 18, 1, 1, 190, 6, bar_color = Color.new(0, 100, 0, 255), end_color = Color.new(0, 255, 0, 255))
    else
      draw_slant_bar(x, y + 18, actor.now_exp, actor.next_exp, 190, 6, bar_color = Color.new(0, 100, 0, 255), end_color = Color.new(255, 255, 255, 255))
    end
    raz_bars_base_exp(actor, x, y)
  end
  #==========================================================================
  # * Draw Parameter
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     type  : parameter type (0-6)
  #==========================================================================
  alias raz_bars_base_parameter draw_actor_parameter  
  def draw_actor_parameter(actor, x, y, type)
    case type
    when 0
      para_color1 = Color.new(100,0,0)
      para_color2 = Color.new(255,0,0)
      para_begin = actor.atk
    when 1
      para_color1 = Color.new(100,100,0)
      para_color2 = Color.new(255,255,0)
      para_begin = actor.pdef
    when 2
      para_color1 = Color.new(100,0,100)
      para_color2 = Color.new(255,0,255)
      para_begin = actor.mdef
    when 3
      para_color1 = Color.new(50,0,100)
      para_color2 = Color.new(50,0,255)
      para_begin = actor.str
    when 4
      para_color1 = Color.new(0,100,0)
      para_color2 = Color.new(0,255,0)
      para_begin = actor.dex
    when 5
      para_color1 = Color.new(50,0,50)
      para_color2 = Color.new(255,0,255)
      para_begin = actor.agi
    when 6
      para_color1 = Color.new(0,100,100)
      para_color2 = Color.new(0,255,255)
      para_begin = actor.int
    end
    draw_slant_bar(x, y + 18, para_begin, 999, 155, 4, bar_color = para_color1,
      end_color = para_color2)
    raz_bars_base_parameter(actor, x, y, type)
  end
  #=========================================================================
  # * Draw Actor ATG
  #     actor : Actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #=========================================================================
  def draw_actor_atg(actor, x, y, width = 144, height = 6)
    if @at_gauge == nil
      # plus_x:     revised x-coordinate
      # rate_x:     revised X-coordinate as (%)
      # plus_y:     revised y-coordinate
      # plus_width: revised width
      # rate_width: revised width as (%)
      # height:     Vertical width
      # align1: Type 1 ( 0: left justify  1: center justify 2: right justify )
      # align2: Type 2 ( 0: Upper stuffing 1: Central arranging  2:Lower stuffing )
      # align3: Gauge type 0:Left justify 1: Right justify
      @plus_x = 0
      @rate_x = 0
      @plus_y = 16
      @plus_width = 0
      @rate_width = 100
      @width = @plus_width + width * @rate_width / 100
      @height = 6
      @align1 = 0
      @align2 = 1
      @align3 = 0
      # Gradation settings:  grade1: Empty gauge   grade2:Actual gauge
      # (0:On side gradation   1:Vertically gradation    2: Slantedly gradation）
      grade1 = 1
      grade2 = 0
      # Color setting. color1: Outermost framework, color2: Medium framework
      # color3: Empty framework dark color, color4: Empty framework light/write color
      color1 = Color.new(0, 0, 0)
      color2 = Color.new(255, 255, 192)
      color3 = Color.new(0, 0, 0, 192)
      color4 = Color.new(0, 0, 64, 192)
      # Color setting of gauge
      # Usually color setting of the time
      color5 = Color.new(0, 64, 80)
      color6 = Color.new(255, 255, 255)#(0, 128, 160)
      # When gauge is MAX, color setting
      color7 = Color.new(80, 0, 0)
      color8 = Color.new(255, 255,255) #(240,0,0)
      # Color setting at time of cooperation skill use
      color9 = Color.new(80, 64, 32)
      color10 = Color.new(255, 255, 255) #(240, 192, 96)
      # Color setting at time of skill permanent residence
      color11 = Color.new(80, 0, 64)
      color12 = Color.new(255,255, 255) #(240, 0, 192)
      # Drawing of gauge
      gauge_rect_at(@width, @height, @align3, color1, color2, color3, color4,
          color5, color6, color7, color8, color9, color10, color11, color12,
          grade1, grade2)
    end
    # Variable at substituting the width of the gauge which is drawn
    if actor.rtp == 0
      at = (width + @plus_width) * actor.atp * @rate_width / 10000
    else
      at = (width + @plus_width) * actor.rt * @rate_width / actor.rtp / 100
    end
    # AT Width Check
    if at > width
      at = width
    end
    # Revision such as the left stuffing central posture of gauge
    case @align1
    when 1
      x += (@rect_width - width) / 2
    when 2
      x += @rect_width - width
    end
    case @align2
    when 1
      y -= @height / 2
    when 2
      y -= @height
    end
    # Draw Border
    for i in 0..height
      self.contents.fill_rect(x + 1.5 + i, y + 12 + height - i, width - 2 , 3,
        Color.new(50, 50, 50, 255))
    end
    # Draw Background
    for i in 1..(height - 1)
      r = 100 * (height - i) / height + 0 * i / height
      g = 100 * (height - i) / height + 0 * i / height
      b = 100 * (height - i) / height + 0 * i / height
      a = 255 * (height - i) / height + 255 * i / height
      self.contents.fill_rect(x + 1.5 + i, y + 12 + height - i, width - 3, 3, 
        Color.new(r, b, g, a))
    end
    # Rect_X control
    if @align3 == 0
      rect_x = 0
    else
      x += @width - at - 1
      rect_x = @width - at - 1
    end

    # Color setting of gauge
    if at == width 
    #Gauge drawing at the time of MAX
      for i in 0..height
        self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y -i + 
        @plus_y, @at_gauge, Rect.new(rect_x, @height * 2, at, @height))
      end
    else
      if actor.rtp == 0
        for i in 0..height
          # Usually gauge drawing of the time
          self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y- i + 
            @plus_y, @at_gauge,Rect.new(rect_x, @height, at, @height))
        end
      else
        if actor.spell == true
          for i in 0..height
            #Gauge drawing at time of cooperation skill use
            self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y - i + 
              @plus_y, @at_gauge, Rect.new(rect_x, @height * 3, at, @height))
          end
        else
          for i in 0..height              
            # Gauge drawing at time of skill permanent residence
            self.contents.blt(x + i + @plus_x + @width * @rate_x / 100, y - i +
              @plus_y, @at_gauge, Rect.new(rect_x, @height * 4, at, @height))
          end
        end
      end
    end
  end
  #=========================================================================
  # * Draw Actor Limit Break Bar
  #     actor : Actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     width : draw spot width
  #=========================================================================
  def draw_actor_lb(actor, x, y, width = 144)
    rate = actor.limitbreak.to_f / LB_MAX
    plus_x = 0
    rate_x = 0
    plus_y = 15
    plus_width = 0
    rate_width = 100
    height = 7
    lb = (width + plus_width) * actor.limitbreak * rate_width / 100 / LB_MAX
    # Drawing of gauge
    if actor.limitbreak == LB_MAX
      # Draw Silver Blue Bar
      draw_slant_bar(x + plus_x + width * rate_x / 100, y + plus_y, lb, width,
        width, height, od_color1 = Color.new(0,80,200,192), 
        od_color2 = Color.new(255,255,255,192))
    else
      # Draw Green Bar
      draw_slant_bar(x + plus_x + width * rate_x / 100, y + plus_y, lb, width,
        width, height, od_color1 = Color.new(31, 128, 0, 128), 
        od_color2 = Color.new(255, 255, 191))
    end
  end  
end

I made the 2 following changes:

In DV's limit break script, lines 615, 616, in the Window_BattleStatus initialize method...
add the arguments (x, y, w, h) to make it compatible with the TBS
Code: 
class Window_BattleStatus < Window_Base
  
  alias lb_init initialize
  def initialize(x, y, w, h)         #added arguments for compat TMB
    lb_init(x, y, w, h)         #added arguments for compat TMB
    if defined?(at_refresh)
      $game_system.lb_rtab_detected = true
    end
    refresh
  end

Then, in the refresh method of the TBS Window_BattleStatus, add the statement to draw the LB bar.
I stuck it under the State for now, but we can rearrange it.

Code: 
  def refresh
    self.contents.clear
    return unless @battler
    draw_battler(@battler, 0, 0) if TBS.options("show_battler")
    # add the limit break bar
    draw_actor_lb(@battler, 0, 95, 110)
    draw_battler_name(@battler, 4, 0)
    draw_battler_graphic(@battler, self.contents.width, 0)
    draw_battler_hp(@battler, 4, 32, self.contents.width)
    draw_battler_sp(@battler, 4, 64, self.contents.width)
    draw_battler_state(@battler, 4, 96, self.contents.width)
  end

Try it out, and test it to see if it shows the gauge working.

Be Well

Ref: TBS
 
Upvote 0 Downvote
Brewmeister

Brewmeister

Sponsor

742
<scratching head>  You didn't start the game with a savefile, did you?

If not, there must be something different in your project -vs- mine.

If you want to compress & upload your game, I'll have a look.

Be Well
 
Upvote 0 Downvote
Brewmeister

Brewmeister

Sponsor

742
Got it! (I think)

It was trying to draw a limitbreak bar for the enemy. I assume they don't need them.

In -Window_BattleStatus- where we call draw_actor_lb, surround it with...
Code: 
    if @battler.is_a?(Game_Actor)
      draw_actor_lb(@battler, 0, 95, 110)
    end

I think that should do it.

Be Well
 
Upvote 0 Downvote
You must log in or register to reply here.

Share this page

Thank you for viewing

HBGames is a leading amateur video game development forum and Discord server open to all ability levels. Feel free to have a nosey around!

Discord

Join our growing and active Discord server to discuss all aspects of game making in a relaxed environment. Join Us

RPG Maker

  • Support & Help
    •
  • Tutorials
    •
  • Plugins - MZ, MV
    •
  • Scripts - Ace, VX, XP
    •
  • Resources
    •

    Content

  • Our Games
    •
  • Games in Development
    •  Emoji by Twemoji.
    Top