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.

Vertical HP/SP/Limit Break Bars

Jonny

Member

I'd like a script that draws bars in battle vertically. I don't need hp/sp bars (you could add them for other people if you want), I need it to draw the limit break bar for DerVVulfman's Limit Break script to the right of the default bars. Here's the script in case you need it (I don't know how to make a spoiler thing):

Code:
#==============================================================================
# *** Limit Break (DVV's)                                          (03-18-2007)
# *** Version 1.6
#------------------------------------------------------------------------------
# by DerVVulfman
# 
#   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 is still designed  'menu-less'  so there would be  no conflicts with any
#   custom menu scripts.  However,  with a little work, making a menu system to
#   change an actor's limit break fill-type (Attack/Defend/Guard) can be accom-
#   plished fairly easily... for the script literate.  :)
#
#   It still requires Cogwheel's HP/SP/EXP Gauge script to draw the Limit Break
#   bar, unless a suitable Bar Drawing script is available.   However,  without 
#   the bar drawing script, you will not get an error.   You just won't see the
#   bars on the screen.   Previous scripts  either had  their own 'cheaper' bar
#   rendering system, or had 'REQUIRED' scripts that without 'em... crashed.
#
#   Bug reported by link2795 for healing items crashing the game when used with
#   the RTAB system.  Bug caught and squashed.
#
#   Removed Window_BattleStatus's 'Update' def as re-aliasation slowed the game
#   down without contributing to anything.  It was a bug in the KGC_OverDrive
#   and previous BattleStatus Mod script combined.
#
#   Converted the positioning system's CONSTANTS into ($)GLOBAL values that you
#   can edit and change from a script call.   That way, positioning of the bars
#   can be changed based on which menu  or battlestatus window you are using at
#   the time.
#
#   Added a feature to hide limit break bars from the menu and the battlestatus
#   screens. Simple enough... just fill the array with the ID of the heroes you
#   don't want to have visible bars.  As it TOO uses ($)GLOBAL values, you can
#   change it through a script call.
#
#   Added save/load feature so ($)GLOBAL values that are changed through script
#   calls can be recorded into the savegame files.
#
#==============================================================================

#==============================================================================
#                         * Configuration Section *
#==============================================================================

  # 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 = [3]  # Set to actor #3, Cyrus
  
 
  # 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)
                
  
  # 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.
  $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)
  
#==============================================================================
#                       * Configuration Section 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_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
    # 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_hide
    # 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_hide       = $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
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------  
  attr_accessor :base_damage
  #--------------------------------------------------------------------------
  # * 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 $rtab_detected; current_dmg = self.damage[attacker]; end
    # Set crit flag (rtab or not)
    current_crit = self.critical
    if $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')
      if attacker.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && attacker.lb_type == 0 
        # Limit Break growth calculation
        lb_calc = current_dmg * LB_RATE[0] * 10 / self.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
        attacker.limitbreak += lb_add
      end
      # 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')
      if attacker.is_a?(Game_Enemy) && self.is_a?(Game_Actor) && self.lb_type == 2 
        lb_calc = current_dmg * LB_RATE[6] * 10 / self.maxhp
        # Adjust Limit Break growth between min & max values
        lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
        self.limitbreak += lb_add
      end
      # IF a battler has died
      if self.dead?
        # Regular killing move check.
        if attacker.is_a?(Game_Actor) && attacker.lb_type == 3
          attacker.limitbreak += LB_RATE[9]  
        # Killed a boss enemy  
        elsif attacker.is_a?(Game_Actor) && attacker.lb_type == 4 &&
          LB_BOSSES.include?(self.id)
          attacker.limitbreak += LB_RATE[10]  
        end
        # Hero dies
        if self.is_a?(Game_Actor) && self.lb_type == 5
          self.limitbreak += LB_RATE[11]  
        end        
      end
    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 $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')
      if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && user.lb_type == 0
        # Limit Break growth calculation
        lb_calc = current_dmg * LB_RATE[0] * 10 / self.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
        user.limitbreak += lb_add
      end
      # When HERO is damaged by the enemy (and tagged for 'Damaged')
      if user.is_a?(Game_Enemy) && self.is_a?(Game_Actor) && self.lb_type == 2
        lb_calc = current_dmg * LB_RATE[6] * 10 / self.maxhp
        # Adjust Limit Break growth between min & max values
        lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
        self.limitbreak += lb_add
      end
      # IF a battler has died
      if self.dead?
        # Regular killing move check.
        if user.is_a?(Game_Actor) && user.lb_type == 3
          user.limitbreak += LB_RATE[9]  
        # Killed a boss enemy  
        elsif user.is_a?(Game_Actor) && user.lb_type == 4 &&
          LB_BOSSES.include?(self.id)
          user.limitbreak += LB_RATE[10]  
        end
        # Hero dies
        if self.is_a?(Game_Actor) && self.lb_type == 5
          self.limitbreak += LB_RATE[11]  
        end        
      end
    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 $rtab_detected; user = battler; end
    # Execute the original process (RTAB or not)
    if $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 $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')
      if user.is_a?(Game_Actor) && self.is_a?(Game_Enemy) && user.lb_type == 0
        # Limit Break growth calculation
        lb_calc = current_dmg * LB_RATE[0] * 10 / self.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
        user.limitbreak += lb_add
      end
      # When HERO is damaged by the enemy (and tagged for 'Damaged')
      if user.is_a?(Game_Enemy) && self.is_a?(Game_Actor) && self.lb_type == 2
        lb_calc = current_dmg * LB_RATE[6] * 10 / self.maxhp
        # Adjust Limit Break growth between min & max values
        lb_add = [[lb_calc, LB_RATE[7]].max, LB_RATE[8]].min
        self.limitbreak += lb_add
      end
      # IF a battler has died
      if self.dead?
        # Regular killing move check.
        if user.is_a?(Game_Actor) && user.lb_type == 3
          user.limitbreak += LB_RATE[9]  
        # Killed a boss enemy  
        elsif user.is_a?(Game_Actor) && user.lb_type == 4 &&
          LB_BOSSES.include?(self.id)
          user.limitbreak += LB_RATE[10]  
        end
        # Hero dies
        if self.is_a?(Game_Actor) && self.lb_type == 5
          self.limitbreak += LB_RATE[11]  
        end        
      end
    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
  #--------------------------------------------------------------------------
  # * 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
  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 $rtab_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 $rtab_detected
            draw_actor_lb(actor, x + ox, y + oy + 32, ow)
          end
        end
      end
      lb_draw_battler_name(actor, x, y)
    end    
  end
  #--------------------------------------------------------------------------
  # * Draw Overdrive 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)
      $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 $rtab_detected
      lb_refresh(number)
    else
      lb_refresh
    end
    # This block is needed only if RTAB in use
    if $rtab_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 Overdrive Ringer hasn't rung
      if actor.limitbreak_ring == false
        # But, if the Overdrive Bar is filled
        if actor.limitbreak == LB_MAX
          # Play the Overdrive Sound Effect
          full_lb_se
          # And Set the Overdrive Ringer to true
          actor.limitbreak_ring = true
        end
      end
      }        
  end
end



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

class Scene_Battle
  #--------------------------------------------------------------------------
  # * 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]
          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 $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 $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 $rtab_detected
      @status_window.update
      @status_window.refresh
     end
    # Perform the original call
    if $rtab_detected; lb_update_p4_s4(battler); else lb_update_p4_s4 ; end    
  end
end

Thank you in advance!
 

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

Content

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