Messages

Well thanks again Blizz ^^ Uber lagless and working.
*bows*

The link is removed since the download site is down since forever.

Ehm I meaned the bars are always full, even when the turns have already elapsed. Sprry for the trouble :F
Observe, here 2 characters have just spend their turn and Zachafer has been waiting for his turn for a sec, and the bar still looks like full.

Well, that's what they say on other forums too
First there was the game name, after came the name for me.

Updates will be asap, but I have to map 40+ maps in this week so I'm busy :/

ECHO: SCAR

This project is no longer in development (nor has it been in two years).

The link is removed since the download site is down since forever.

This stuff is great you know I laughed the whole time reading.
I really hope you'll get your sprite

Setting the blinking false will cause the AT bar to always be full yellow Tho the turns still go the same time.

In other words:
I want a LAGLESS window around the HP/MP/Turn bar HUD, and fixed HP/MP bars which will NOT go over each other.

I need a window edit (totally lagless) to my RTAB.

The original System looks like this, note the bars go over each other

#===============================================================================
# ** BattleStatus Modification (RTAB Version)                            Credits
#    by DerVVulfman
#    Version 1.1
#    06-22-06
#
#-------------------------------------------------------------------------------
# ** A MODIFICATION OF
# ** Real time active battle (RTAB) Ver 1.12
# ** RTAB engine available at...
# ** http://members.jcom.home.ne.jp/cogwheel/
#
#-------------------------------------------------------------------------------
#  This script is a reponse  to a friend who wanted  the battle status window to
#  display the hero(s) information in a different manner.  Instead of displaying
#  each hero's information  directly underneath of them,  it displays it along a
#  single horizontal line in the style of the Final Fantasy games.
#
#  EX:  ARSHES        HP 204 / SP 199   [Normal ]        [=========]
#       BASIL         HP 184 / SP  49   [Knockout]       [=========]
#       GLORIA        HP 234 / SP 299   [Normal ]        [=========]
#       HILDA         HP 214 / SP 129   [Normal ]        [=========]
#
#  As a bonus, the system can Right-Justify the display and set the transparency
#  of the status window.   The only caveat of this is that  it doesn't highlight
#  the name of the hero in action. But, I have altered the battle command window
#  to change its height to appear just over the name (or atb bar) of the current
#  hero in action (instead of moving left to right).
#
#-------------------------------------------------------------------------------
#  There are two editable values:
#
#  BATTLESTATUS_LEFTJUSTIFY       Controls whether  the display shows the hero's
#                                 data left to right, or right to left.  It is a
#                                 boolean value (either true or false).
#
#                                 true - This setting will display the data just
#                                        like the above example.
#
#                                 false - This reverses the display  so the name
#                                         of the hero  is on the right,  and the 
#                                         ATB bar is on the left.
#
#
#  BATTLESTATUS_OPACITY           Controls the transparency  of the display  and
#                                 of the battle command window. The value ranges
#                                 from 0 to 2...
#
#                                 0 - The display and command windows are set to
#                                     a totally solid display.
#
#                                 1 - This is the 'semi-transparent' look of the
#                                     RTAB system,  with the exception  that the
#                                     battle command window is  more solid so it
#                                     will show up over the battlestatus window.
#
#                                 2 - This setting  will make  the battle status
#                                     window totally invisible.  Only the battle
#                                     command window will be visible,  though it
#                                     will be semi-transparent for effect.
#
#  BATTLESTATUS_FULLWINDOW        Controls whether the display resizes itself to
#                                 fit the total number  of heroes  in the party.
#                                 It's a boolean value (either true or false).
#
#                                 true - This setting will  increase or decrease
#                                        the height of the window itself as well
#                                        as adjust its position on the screen.
#
#                                 false - This keeps  the battlestatus window in
#                                         the same position  and size regardless
#                                         of the number of party members.
#
#
#-------------------------------------------------------------------------------
#
#  * Scripts Added
#    Window_Base            - draw_battler_name
#
#  * Scripts Edited
#    Window_BattleStatus    - initialize        (RTAB version Edit)
#    Window_BattleStatus    - update            (RTAB version Edit)
#    Window_ActorStatus     - initialize        (RTAB version Edit)
#    Window_DetailsStatus   - initialize        (RTAB version Edit)
#    Window_DetailsStatus   - refresh           (RTAB version Edit)
#    Window_DetailsStatus   - update            (RTAB version Edit)
#    Scene_Battle (part 3)  - initialize        (Default Edit)
#
#-------------------------------------------------------------------------------
#  * Bug Fixes
#    System was designed to ensure that 4 characters were playable.  However, it
#    screwed up the display's vertical position when less than 4 characters were
#    in the party.  This has been fixed.
#
#-------------------------------------------------------------------------------


#==============================================================================
# ** EDITABLE CONSTANTS
#==============================================================================
BATTLESTATUS_LEFTJUSTIFY = true  
BATTLESTATUS_OPACITY = 2 
BATTLESTATUS_FULLWINDOW = false


#==============================================================================
# ** Window_BattleStatus
#------------------------------------------------------------------------------
# * It is the window which indicates the status of the party member in the 
#   battle picture.
#==============================================================================

class Window_BattleStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    
    if BATTLESTATUS_FULLWINDOW
      y = 320 
      super(0, y, 640, 160)
    else
      y = 480 - ($game_party.actors.size * 40)
      height = $game_party.actors.size * 40
      super(0, y, 640, height)
    end
    
    case BATTLESTATUS_OPACITY
    when 0
      self.back_opacity = 255
      self.opacity = 255
    when 1
      self.back_opacity = 160
      self.opacity = 255
    when 2
      self.back_opacity = 0
      self.opacity = 0
    end
    
    @actor_window = []
    for i in 0...$game_party.actors.size
      @actor_window.push(Window_ActorStatus.new(i, y + i * 40))
    end
    @level_up_flags = [false, false, false, false]
    refresh
  end
  #--------------------------------------------------------------------------
  # * Frame Renewal
  #--------------------------------------------------------------------------
  def update
    super
    if BATTLESTATUS_FULLWINDOW
      if self.y != 320
        self.y = 320 
        self.height = 320
        for window in @actor_window
          window.dispose
        end
        @actor_window = []
        for i in 0...$game_party.actors.size
          @actor_window.push(Window_ActorStatus.new(i, y + i * 40))
        end
        refresh      
      end
    else
      if self.y != 480 - ($game_party.actors.size * 40)
        self.y = 480 - ($game_party.actors.size * 40)
        self.height = $game_party.actors.size * 40
        for window in @actor_window
          window.dispose
        end
        @actor_window = []
        for i in 0...$game_party.actors.size
          @actor_window.push(Window_ActorStatus.new(i, y + i * 40))
        end
        refresh
      end
    end
    
    for window in @actor_window
      window.update
    end
  end
end

#==============================================================================
# ** Window_ActorStatus
#------------------------------------------------------------------------------
# * It is the window which indicates the status of the party member respectively
#   in the battle picture.
#==============================================================================

class Window_ActorStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(id, y)
    @actor_num = id
    super(0, y, 640, 160)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.opacity = 0
    self.back_opacity = 0
    actor = $game_party.actors[@actor_num]
    @actor_nm = actor.name
    @actor_mhp = actor.maxhp
    @actor_msp = actor.maxsp
    @actor_hp = actor.hp
    @actor_sp = actor.sp
    @actor_st = make_battler_state_text(actor, 120, true)
    @status_window = []
    for i in 0...5
      @status_window.push(Window_DetailsStatus.new(actor, i, y))
    end
    refresh(false)
  end
end
#==============================================================================
# ** Window_DetailsStatus
#------------------------------------------------------------------------------
# * It is the window which indicates the status of the actor in individually in
#   the battle picture.
#==============================================================================

class Window_DetailsStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(actor, id, y)
    @status_id = id
    super(0, y, 640, 64)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.opacity = 0
    self.back_opacity = 0
    refresh(actor, false)
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh(actor, level_up_flags = false)
    self.contents.clear
    if BATTLESTATUS_LEFTJUSTIFY
      # Draw Name/Hp etc left to right
      case @status_id
      when 0
        draw_actor_name(actor, 4, -8)
      when 1
        draw_actor_hp(actor, 152, -8, 80)
      when 2
        draw_actor_sp(actor, 248, -8, 80)
      when 3
        if level_up_flags
          self.contents.font.color = normal_color
          self.contents.draw_text(344, -8, 120, 32, "LEVEL UP!")
        else
          draw_actor_state(actor, 344, -8)
        end
      when 4
        draw_actor_atg(actor, 488, -8, 120)
      end
    else
      # Draw Name/Hp etc right to left
      case @status_id
      when 0
        draw_battler_name(actor, 488, -8)
      when 1
        draw_actor_hp(actor, 296, -8, 80)
      when 2
        draw_actor_sp(actor, 392, -8, 80)
      when 3
        if level_up_flags
          self.contents.font.color = normal_color
          self.contents.draw_text(160, -8, 120, 32, "LEVEL UP!")
        else
          draw_actor_state(actor, 160, -8)
        end
      when 4
        draw_actor_atg(actor, 0, -8, 120)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Frame renewal
  #--------------------------------------------------------------------------
  def update
    #At the time of main phase opacity is lowered a little
    if $game_temp.battle_main_phase
      self.contents_opacity -= 4 if self.contents_opacity > 191
    else
      self.contents_opacity += 4 if self.contents_opacity < 255
    end
  end
end

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

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Draw Name (battler)
  #     actor : actor
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_battler_name(actor, x, y)
    self.contents.font.color = normal_color
    self.contents.draw_text(x, y, 120, 32, actor.name, 2)
  end  
end


#==============================================================================
# ** Scene_Battle (Division definition 3)
#------------------------------------------------------------------------------
# * It is the class which processes the battle picture.
#==============================================================================
class Scene_Battle
  #--------------------------------------------------------------------------
  # * Setup of actor command window
  #--------------------------------------------------------------------------
  def phase3_setup_command_window
    # Nullifying the party command window
    @party_command_window.active = false
    @party_command_window.visible = false
    # Enabling the actor command window
    @actor_command_window.active = true
    @actor_command_window.visible = true

    # My corrections to set the Command window & transparency effect
    # Setting the position of the actor command window
    if BATTLESTATUS_FULLWINDOW
      @actor_command_window.y = (160 + (@actor_index * 40))
    else
      @actor_command_window.y = (320 - ($game_party.actors.size * 40)) +
        (@actor_index * 40)
    end
      
                              
    case BATTLESTATUS_OPACITY
    when 0
      @actor_command_window.back_opacity = 255
      @actor_command_window.opacity = 255
    when 1
      @actor_command_window.back_opacity = 255
      @actor_command_window.opacity = 191
    when 2
      @actor_command_window.back_opacity = 255
      @actor_command_window.opacity = 160
    end                              
    @actor_command_window.z=125
    # End of corrections
    
    # Setting the index to 0
    @actor_command_window.index = 0
  end
end

# HP/SP/EXP Gauge Script v1.00
# Distribution original support URL
# http://members.jcom.home.ne.jp/cogwheel/

#==============================================================================
# ** 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
  def now_exp
    return @exp - @exp_list[@level]
  end
  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 HP Gauge
  #--------------------------------------------------------------------------
  # Modification of the original Draw HP process
  alias :draw_actor_hp_hpsp :draw_actor_hp
  def draw_actor_hp(actor, x, y, width = 144)
    # Determine the rate of fill based on the actor's HP and HP Max
    if actor.maxhp != 0
      rate = actor.hp.to_f / actor.maxhp
    else
      rate = 0
    end
    # 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 = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    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, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    # Color setting of gauge
    # Usually color setting of the time    
    color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
    color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
    # Determine the gauge's width & fill based on the actor's HP
    if actor.maxhp != 0
      hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
    else
      hp = 0
    end
    # Drawing of gauge
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, hp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # Call the original Draw HP process
    draw_actor_hp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Draw SP Gauge
  #--------------------------------------------------------------------------
  # Modification of the original Draw SP process
  alias :draw_actor_sp_hpsp :draw_actor_sp
  def draw_actor_sp(actor, x, y, width = 144)
    # Determine the rate of fill based on the actor's SP and SP Max
    if actor.maxsp != 0
      rate = actor.sp.to_f / actor.maxsp
    else
      rate = 1
    end
    # 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 = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    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, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(0, 64, 0, 192)
    # Color setting of gauge
    # Usually color setting of the time       
    color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
    color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
    # Determine the gauge's width & fill based on the actor's SP
    if actor.maxsp != 0
      sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
    else
      sp = (width + plus_width) * rate_width / 100
    end
    # Drawing of gauge
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, sp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # Call the original Draw HP process
    draw_actor_sp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Draw EXP Gauge
  #--------------------------------------------------------------------------
  # Modification of the original Draw HP process
  alias :draw_actor_exp_hpsp :draw_actor_exp
  def draw_actor_exp(actor, x, y, width = 204)
    # Determine the rate of fill based on the actor's EXP and Next EXP
    if actor.next_exp != 0
      rate = actor.now_exp.to_f / actor.next_exp
    else
      rate = 1
    end
    # 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 = 25
    plus_width = 0
    rate_width = 100
    height = 10
    align1 = 1
    align2 = 2
    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, 192)
    color2 = Color.new(255, 255, 192, 192)
    color3 = Color.new(0, 0, 0, 192)
    color4 = Color.new(64, 0, 0, 192)
    # Color setting of gauge
    # Usually color setting of the time      
    color5 = Color.new(80 * rate, 80 - 80 * rate ** 2, 80 - 80 * rate, 192)
    color6 = Color.new(240 * rate, 240 - 240 * rate ** 2, 240 - 240 * rate, 192)
    # Determine the gauge's width & fill based on the actor's Next EXP
    if actor.next_exp != 0
      exp = (width + plus_width) * actor.now_exp * rate_width /
                                                          100 / actor.next_exp
    else
      exp = (width + plus_width) * rate_width / 100
    end
    # Drawing of gauge
    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
                width, plus_width + width * rate_width / 100,
                height, exp, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    # Call the original Draw EXP process
    draw_actor_exp_hpsp(actor, x, y)
  end
  #--------------------------------------------------------------------------
  # * Drawing of gauge
  #--------------------------------------------------------------------------
  def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
                color1, color2, color3, color4, color5, color6, grade1, grade2)
    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
    # Framework Drawing
    self.contents.fill_rect(x, y, width, height, color1)
    self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
    if align3 == 0
      if grade1 == 2
        grade1 = 3
      end
      if grade2 == 2
        grade2 = 3
      end
    end
    if (align3 == 1 and grade1 == 0) or grade1 > 0
      color = color3
      color3 = color4
      color4 = color
    end
    if (align3 == 1 and grade2 == 0) or grade2 > 0
      color = color5
      color5 = color6
      color6 = color
    end
    # Drawing of empty gauge
    self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
                                  color3, color4, grade1)
    if align3 == 1
      x += width - gauge
    end
    #  Drawing of actual gauge
    self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
                                  color5, color6, grade2)
  end
end

#------------------------------------------------------------------------------
# New routine added to the Bitmap class. 
#============================================================================== 

class Bitmap
#-------------------------------------------------------------------------- 
# * Rectangle Gradation Indicator
#   color1: Start color 
#   color2: Ending color 
#   align: 0: On side gradation 
#          1: Vertically gradation 
#          2: The gradation (intense concerning slantedly heavily note) 
#-------------------------------------------------------------------------- 
  def gradation_rect(x, y, width, height, color1, color2, align = 0)
    if align == 0
      for i in x...x + width
        red   = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - x) / (width - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - x) / (width - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - x) / (width - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(i, y, 1, height, color)
      end
    elsif align == 1
      for i in y...y + height
        red   = color1.red +
                (color2.red - color1.red) * (i - y) / (height - 1)
        green = color1.green +
                (color2.green - color1.green) * (i - y) / (height - 1)
        blue  = color1.blue +
                (color2.blue - color1.blue) * (i - y) / (height - 1)
        alpha = color1.alpha +
                (color2.alpha - color1.alpha) * (i - y) / (height - 1)
        color = Color.new(red, green, blue, alpha)
        fill_rect(x, i, width, 1, color)
      end
    elsif align == 2
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                  ((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    elsif align == 3
      for i in x...x + width
        for j in y...y + height
          red   = color1.red + (color2.red - color1.red) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          green = color1.green + (color2.green - color1.green) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          blue  = color1.blue + (color2.blue - color1.blue) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          alpha = color1.alpha + (color2.alpha - color1.alpha) *
                ((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
          color = Color.new(red, green, blue, alpha)
          set_pixel(i, j, color)
        end
      end
    end
  end
end

Thu the Blizzard's 3-party fix (which is needed lagless) looks like this:

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# RTAB BattleStatus Blizz-Art Hack by Blizzard
# Version: 1.0
# Date: 4.7.2007
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
# 
# Explanation:
# 
# This script will hack into RTAB's code and mod the battle status for a 3
# member party.
# 
# 
# Features:
# 
# - uses "Super Lagless Bar" code
# - overrides SephirothSpawn's slant bars and DerVVulfman's BattleStatus mod
# - possiblity to use original bar style from "Gradient Bar Styler"
# - can mod the text in the status window without affecting the rest of the
#   game
# - fixes the command window position, size and opacity
# - the currently selected actor has his AT Bar color changed to red instead of
#   yellow
# - AT Bar is blinking when at 100%
# - overrides the stupid refresh interruption when somebody is attacking so the
#   bars keep blinking, no matter what
# - adds HP/SP/EXP bars as well
# 
# 
# Instructions:
# 
# To apply this code, put it UNDER ALL of the RTAB codes.
# 
# 
# If you have any problems, please report them here:
# http://www.chaosproject.co.nr
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=

TEXTTYPE = 1 # 0 - normal, 1 - shadowed, 2 - outlined
BACK_COLOR = Color.new(0, 0, 0, 192) # color of shadow/outline
ORIGINAL = true # true changes the bar display to the original gradient style
ATB_TEXT = 'AT' # AT Bar text (note that too long strings WILL cause lag)

#==============================================================================
# Bitmap
#==============================================================================

class Bitmap
 
 # RTAB updates the AT bar constantly. Without an extremely optimized code
 # imense lag would occur. The code has a complexity of just n (instead of n^2
 # like usual bar scripts) and instead of coloring each pixel, it treats the
 # slant bar like a normal gradient bar, but creates an optical illusion of a
 # totally slanted bar.
 def super_lagless_bar(x, y, w, color1, color2, color3, rate)
   offset = 8
   height = 16
   x += offset
   y += height
   for i in 0...offset+3
     fill_rect(x-i, y+i-2, w+3, 1, Color.new(0, 0, 0))
   end
   if ORIGINAL
     for i in 0...offset+1
       fill_rect(x-i, y+i-1, w+1, 1, Color.new(255, 255, 255))
     end
   end
   for i in 0...offset
     red = color3.red * i / offset
     green = color3.green * i / offset
     blue = color3.blue * i / offset
     fill_rect(x-i+1, y+i-1, w, 1, Color.new(red, green, blue))
   end
   if (w*rate).to_i >= offset
     for i in 0...(w*rate).to_i+offset
       red = color1.red + (color2.red-color1.red)*i / ((w+offset)*rate)
       green = color1.green + (color2.green-color1.green)*i / ((w+offset)*rate)
       blue = color1.blue + (color2.blue-color1.blue)*i / ((w+offset)*rate)
       oy = i < offset ? offset-i : 0
       off = i < offset ? i : i > w*rate ? (w*rate).to_i+offset-i : offset
       fill_rect(x+i-offset+1, y+oy-1, 1, off, Color.new(red, green, blue))
     end
   else
     for i in 0...(w * rate).to_i
       for j in 0...offset
         red = color1.red + (color2.red-color1.red)*i / (w*rate)
         green = color1.green + (color2.green-color1.green)*i / (w*rate)
         blue = color1.blue + (color2.blue-color1.blue)*i / (w*rate)
         set_pixel(x+i-j+1, y+j-1, Color.new(red, green, blue))
       end
     end
   end
 end
 
end

#==============================================================================
# Window_Base
#==============================================================================

class Window_Base
 
 # byebye, Seph's slant bars :)
 def draw_slant_bar(a, b, c, d, e = 0, f = 0, g = nil, h = nil)
 end
 
 # adds bar wherever HP are displayed
 alias draw_actor_hp_blizzart_gradient_later draw_actor_hp
 def draw_actor_hp(actor, x, y, w = 148)
   w -= 12
   rate = actor.hp.to_f / actor.maxhp
   if rate > 0.6
     color1 = Color.new(80 - 150 * (rate-0.6), 80, 50 * (rate-0.6))
     color2 = Color.new(240 - 450 * (rate-0.6), 240, 150 * (rate-0.6))
   elsif rate > 0.2 and rate <= 0.6
     color1 = Color.new(80, 200 * (rate-0.2), 0)
     color2 = Color.new(240, 600 * (rate-0.2), 0)
   elsif rate <= 0.2
     color1 = Color.new(400 * rate, 0, 0)
     color2 = Color.new(240, 0, 0)
   end
   color3 = Color.new(0, 80, 0)
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
   draw_actor_hp_blizzart_gradient_later(actor, x, y)
 end
 
 # adds bar wherever SP are displayed
 alias draw_actor_sp_blizzart_gradient_later draw_actor_sp
 def draw_actor_sp(actor, x, y, w = 148)
   w -= 12
   rate = (actor.maxsp > 0 ? actor.sp.to_f / actor.maxsp : 0)
   if rate > 0.4
     color1 = Color.new(60 - 66 * (rate-0.4), 20, 80)
     color2 = Color.new(180 - 200 * (rate-0.4), 60, 240)
   elsif rate <= 0.4
     color1 = Color.new(20 + 100 * rate, 50 * rate, 26 + 166 * rate)
     color2 = Color.new(60 + 300 * rate, 150 * rate, 80 + 400 * rate)
   end
   color3 = Color.new(0, 0, 80, 192) 
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
   draw_actor_sp_blizzart_gradient_later(actor, x, y)
 end
 
 # adds bar wherever EXP are displayed
 alias draw_actor_exp_blizzart_gradient_later draw_actor_exp
 def draw_actor_exp(actor, x, y, w = 180)
   rate = (actor.next_exp != 0 ? actor.now_exp.to_f / actor.next_exp : 1)
   if rate < 0.5
     color1 = Color.new(20 * rate, 60, 80)
     color2 = Color.new(60 * rate, 180, 240)
   elsif rate >= 0.5
     color1 = Color.new(20 + 120 * (rate-0.5), 60 + 40 * (rate-0.5), 80)
     color2 = Color.new(60 + 360 * (rate-0.5), 180 + 120 * (rate-0.5), 240)
   end
   color3 = Color.new(80, 80, 80)
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
   draw_actor_exp_blizzart_gradient_later(actor, x, y)
 end
 
end

#==============================================================================
# Window_BattleStatus
#==============================================================================

class Window_BattleStatus
 
 # initialization
 def initialize
   super(160, 352, 480, 128)
   self.contents = Bitmap.new(width - 32, height - 32)
   self.contents.font.bold = true
   self.contents.font.name = "Arial"
   self.contents.font.size = 22
   @level_up_flags = [false, false, false]
   @glow_flags = [false, false, false]
   @name = []
   @hp = []
   @sp = []
   @atp = []
   for i in 0...$game_party.actors.size
     norm_refresh(i)
   end
 end
 
 # necessary to override RTAB method.
 def refresh(num = 0)
   norm_refresh(num-1) if num != 0
 end
 
 # necessary to override RTAB method.
 def at_refresh(num = 0)
   xat_refresh(num-1) if num != 0
 end
 
 # refreshes the whole status for actor with index i
 def norm_refresh(i)
   draw_name($game_party.actors[i], i) if @name[i] != $game_party.actors[i].name
   draw_hp($game_party.actors[i], i) if @hp[i] != $game_party.actors[i].hp
   draw_sp($game_party.actors[i], i) if @sp[i] != $game_party.actors[i].sp
   @name[i] = $game_party.actors[i].name
   @hp[i] = $game_party.actors[i].hp
   @sp[i] = $game_party.actors[i].sp
   xat_refresh(i)
 end
 
 # refreshes the AT Bar for actor with index i
 def xat_refresh(i)
   return if @atp[i] == $game_party.actors[i].atp and @atp[i] != 100
   self.contents.font.size -= 4
   self.contents.font.italic = true
   self.contents.fill_rect(349, i*32, 98, 32, Color.new(0, 0, 0, 0))
   draw_actor_atb($game_party.actors[i], 349, i*32, 84)
   draw_text_special(358, -1+i*32, 96, 32, ATB_TEXT)
   self.contents.font.size += 4
   self.contents.font.italic = false
   @atp[i] = $game_party.actors[i].atp
 end
 
 # draws name
 def draw_name(actor, i)
   self.contents.fill_rect(0, i*32, 90, 40, Color.new(0, 0, 0, 0))
   draw_text_special(4, i*32, 84, 32, actor.name)
 end
 
 # draws HP and bar
 def draw_hp(actor, i)
   self.contents.fill_rect(90, i*32, 140, 40, Color.new(0, 0, 0, 0))
   rate = actor.hp.to_f / actor.maxhp
   if rate > 0.6
     color1 = Color.new(80 - 150 * (rate-0.6), 80, 50 * (rate-0.6))
     color2 = Color.new(240 - 450 * (rate-0.6), 240, 150 * (rate-0.6))
   elsif rate > 0.2 and rate <= 0.6
     color1 = Color.new(80, 200 * (rate-0.2), 0)
     color2 = Color.new(240, 600 * (rate-0.2), 0)
   elsif rate <= 0.2
     color1 = Color.new(400 * rate, 0, 0)
     color2 = Color.new(240, 0, 0) 
   end
   color3 = Color.new(0, 80, 0)
   self.contents.super_lagless_bar(124, i*32, 86, color1, color2, color3, rate)
   self.contents.font.italic = true
   self.contents.font.color = system_color
   draw_text_special(94, i*32, 100, 32, $data_system.words.hp)
   self.contents.font.italic = false
   self.contents.font.size -= 4
   self.contents.font.color = actor.hp == 0 ? knockout_color :
       actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
   draw_text_special(86, i*32, 80, 32, actor.hp.to_s, 2)
   self.contents.font.color = normal_color
   draw_text_special(74, i*32, 100, 32, "/", 2)
   draw_text_special(178, i*32, 80, 32, actor.maxhp.to_s)
   self.contents.font.size += 4
 end
 
 # draws SP and bar
 def draw_sp(actor, i)
   self.contents.fill_rect(230, i*32, 129, 40, Color.new(0, 0, 0, 0))
   rate = (actor.maxsp > 0 ? actor.sp.to_f / actor.maxsp : 0)
   if rate > 0.4
     color1 = Color.new(60 - 66 * (rate-0.4), 20, 80)
     color2 = Color.new(180 - 200 * (rate-0.4), 60, 240)
   elsif rate <= 0.4
     color1 = Color.new(20 + 100 * rate, 50 * rate, 26 + 166 * rate)
     color2 = Color.new(60 + 300 * rate, 150 * rate, 80 + 400 * rate)
   end
   color3 = Color.new(0, 0, 80, 192) 
   self.contents.super_lagless_bar(260, i*32, 72, color1, color2, color3, rate)
   self.contents.font.italic = true
   self.contents.font.color = system_color
   draw_text_special(230, i*32, 100, 32, $data_system.words.sp)
   self.contents.font.italic = false
   self.contents.font.size -= 4
   self.contents.font.color = actor.sp == 0 ? knockout_color :
       actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
   draw_text_special(216, i*32, 80, 32, actor.sp.to_s, 2)
   self.contents.font.color = normal_color
   draw_text_special(204, i*32, 100, 32, "/", 2)
   draw_text_special(308, i*32, 80, 32, actor.maxsp.to_s)
   self.contents.font.size += 4
 end
 
 # draws the AT bar
 def draw_actor_atb(actor, x, y, w = 120)
   if actor.rtp != 0
     rate = 1 - actor.rt.to_f / actor.rtp
     color1 = Color.new(0, 48, 64)
     color2 = Color.new(0, 192, 255)
   else 
     rate = actor.atp.to_f / 100
     frame = Graphics.frame_count % Graphics.frame_rate
     glow = (frame < 6 ? frame / 5.0 : frame < 12 ? (11-frame) / 5.0 : 0)
     if rate == 1
       @glow_flags[actor.index] = false if glow == 0
     else
       @glow_flags[actor.index] = (glow != 0)
     end
     glow = 0 if @glow_flags[actor.index]
     if actor == $scene.active_actor
       color1 = Color.new(64 + glow*191, glow*255, glow*255)
       color2 = Color.new(255, glow*255, glow*255)
     else
       color1 = Color.new(64 + glow*191, 64 + glow*191, glow*255)
       color2 = Color.new(255, 255, glow*255)
     end
   end
   color3 = Color.new(80, 80, 80)
   self.contents.super_lagless_bar(x, y, w, color1, color2, color3, rate)
 end
 
 # mods the status window text
 def draw_text_special(x2, y2, w2 = 0, h2 = 0, text2 = "", a2 = 0)
   if x2.is_a?(Rect)
     x, y, w, h, text, a = x2.x, x2.y, x2.width, x2.height, y2, w2
   else
     x, y, w, h, text, a = x2, y2, w2, h2, text2, a2
   end
   save_color = self.contents.font.color.clone
   self.contents.font.color = BACK_COLOR
   if TEXTTYPE > 0
     self.contents.draw_text(x+1, y+1, w, h, text, a)
     if TEXTTYPE == 2
       self.contents.draw_text(x-1, y+1, w, h, text, a)
       self.contents.draw_text(x+1, y-1, w, h, text, a)
       self.contents.draw_text(x-1, y-1, w, h, text, a)
     end
   end
   self.contents.font.color = save_color
   self.contents.draw_text(x, y, w, h, text, a)
 end
 
 # pointless, but necessary to override RTAB method
 def update
   super
 end
 
 # pointless, but necessary to override RTAB method
 def dispose
   super
 end
 
end

#==============================================================================
# Scene_Battle
#==============================================================================

class Scene_Battle
 
 attr_reader :active_actor
 
 # fixes the command window position, size and opacity
 alias ph3_scw_rtab_battlestatus_hack_later phase3_setup_command_window
 def phase3_setup_command_window
   ph3_scw_rtab_battlestatus_hack_later
   @actor_command_window.height = 128
   @actor_command_window.x = 0
   @actor_command_window.y = 480 - @actor_command_window.height
   @actor_command_window.back_opacity = @actor_command_window.opacity = 255
 end
 
 # overrides the stupid refresh interruption when somebody is attacking
 alias upd_ph0_rtab_battlestatus_hack_later update_phase0
 def update_phase0
   for i in 0...$game_party.actors.size
     @status_window.xat_refresh(i)
   end
   upd_ph0_rtab_battlestatus_hack_later
 end
 
end

I'd like to get the window, but the original bars etc, because the window flash etc. lags alot on many betatester's computers.

Thanks,
Tsurara

Just to say the music at the beginning is from Final Fantasy X, composed by Nobuo Uematsu.

Nice game for a sample.

Also when I was coming down from Post tower, and a mimic attacked me the game couldn't find a file.

And one more thing: Am I free to use that piece of music in my game if I credit E Nomine and you?

Updated version, Stealth v.2, now you can use it with press-and-hold method too
Still download from here: http://www.rpgf.org/files/StealthMod.zip

In RPG Maker original buttons Y = S.

[Stealthy Mod Minigame]

Stealthy Mod Minigame
Version: 1.0
Type: Mini-Game

Introduction
A stealthy mod/minigame by Tsurara. Please don't use without crediting.


Features

• Can be activated easily with S Button
  
• Allows one to be stealthy
  

Screenshots

None, download the demo.

Demo

http://www.rpgf.org/files/StealthMod.zip

Instructions

Instructions in Demo.

Credits and Thanks

• Tsurara
  

Author's Notes


ATTENTION! Press S once to activate stealth mod, press again to put it off. Do not hold the S button!