Jump to content
New account registrations are disabed. This website is now an archive. Read more here.
  • 0
zahraa

HP/SP gauge animation indication vesion 1.03

Asked by zahraa

Question

zahraa    26

zahraa
Posted

Hi everybody!

Well,I'm not very lucky these days..another problem. :angry:

I have HP/SP gauge animation indication vesion 1.03 script (posted at the end of topic) and Tanketai's side view battle system together.

When i put HP/SP gauge script above " * Sideview 2 " script (you'll find this script in demo of Tanketai's side view battle system) and start battling enemies and an enemy attacks , number of HP gets lower but HP bar takes a while to be lower.

and when i put this script below " * Sideview 2 " script and open my game,this error comes :

Script " * Sideview 1 " line 210: ArgumentError occurred

wrong number of arguments (3 for 2)

I'm so sorry i know my English is too bad

please tell me if you need more explanation.

also i didn't forget to post HP/SP gauge animation indication 1.03 script :grin:. here you go:

 

# HP/SP gauge animation indication Ver1.03
# 07/01/11
# 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
  #--------------------------------------------------------------------------
  # * Object Initialization
  #      x        : window x-coordinate
  #      y        : window y-coordinate
  #      width  : window width
  #      height : window height
  #--------------------------------------------------------------------------
  alias :initialize_gauge :initialize
  def initialize(x, y, width, height)
        initialize_gauge(x, y, width, height)
        # Initialize HP and SP gauge values
        @hp_gauge = {}
        @sp_gauge = {}
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  alias :dispose_gauge :dispose
  def dispose
        # ƒQ[ƒW‚Ìíœ
        gauge_delete
        # ƒIƒŠƒWƒiƒ‹‚̉ð•úˆ—
        dispose_gauge
  end
  #--------------------------------------------------------------------------
  # * Gauge Delete
  #--------------------------------------------------------------------------
  def gauge_delete
        # HP Æ’Q[Æ’W‚ÌËŽ
        for gauge in @hp_gauge.values
          gauge[0].bitmap.dispose
          gauge[0].dispose
        end
        # SP ƒQ[ƒW‚ÌXV
        for gauge in @sp_gauge.values
          gauge[0].bitmap.dispose
          gauge[0].dispose
        end
        @hp_gauge = {}
        @sp_gauge = {}
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias :update_gauge :update
  def update
        update_gauge
        # HP ƒQ[ƒW‚ÌXV
        for gauge in @hp_gauge.values
          gauge_refresh(gauge, 0)
        end
        # SP ƒQ[ƒW‚ÌXV
        for gauge in @sp_gauge.values
          gauge_refresh(gauge, 1)
        end
  end
  #--------------------------------------------------------------------------
  # * 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)
        # ‰•`‰æ‚Ìê‡
        if @hp_gauge[actor] == nil
          # ƒQ[ƒW‚
          height = 10
          # FÃ’èBcolor1:Å OËœgCcolor2:’†˜g
          # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
          color1 = Color.new(0, 0, 0, 192)
          color2 = Color.new(255, 255, 192, 192)
          color3 = Color.new(64, 0, 0, 192)
          color4 = Color.new(0, 0, 0, 192)
          # ‹óƒQ[ƒW‚Ì•`‰æ
          @hp_frame = gauge_rect(width, height, color1, color2, color3, color4)
          sprite = Sprite.new
          sprite.bitmap = Bitmap.new(width, height)
          sprite.x = self.x + x + 16
          sprite.y = self.y + y + 42 - height
          sprite.z = self.z + 1
          count = rand(400)
          # •Ãâ€rate‚É Œ»Ã‚ÌHP/MHP‚ð‘ã“ü
          if actor.maxhp != 0
                rate = ((width - 4) * actor.hp.to_f / actor.maxhp).ceil
          else
                rate = width - 4
          end
          # ˆÊ’u“™î•ñ‚Ì‹L‰¯
          @hp_gauge[actor] = [sprite, actor, rate, count, x, y - height]
          # ƒQ[ƒW•`‰æ
          gauge_refresh(@hp_gauge[actor], 0)
          # Æ’^[Æ’QÆ’bÆ’gÆ’EÆ’Bƒ“ƒhÆ’E‚Ìê‡A‰Šúó‘Ô‚Ãâ€Ã±â€¢\Ž¦
          @hp_gauge[actor][0].visible = false if self.is_a?(Window_Target)
        end
        # •Ãâ€rate‚É Œ»Ã‚ÌHP/MHP‚ð‘ã“ü
        if actor.maxhp != 0
          rate = ((width - 4) * actor.hp.to_f / actor.maxhp).ceil
        else
          rate = width - 4
        end
        @hp_gauge[actor][2] = rate
        # ƒIƒŠƒWƒiƒ‹‚ÌHP•`‰æˆ—‚ðŒÄ‚Ño‚µ
        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)
        # ‰•`‰æ‚Ìê‡
        if @sp_gauge[actor] == nil
          # ƒQ[ƒW‚
          height = 10
          # FÃ’èBcolor1:Å OËœgCcolor2:’†˜g
          # color3:‹óƒQ[ƒWƒ_[ƒNƒJƒ‰[Ccolor4:‹óƒQ[ƒWƒ‰ƒCƒgƒJƒ‰[
          color1 = Color.new(0, 0, 0, 192)
          color2 = Color.new(255, 255, 192, 192)
          color3 = Color.new(0, 64, 64, 192)
          color4 = Color.new(0, 0, 0, 192)
          # ‹óƒQ[ƒW‚Ì•`‰æ
          @sp_frame = gauge_rect(width, height, color1, color2, color3, color4)
          sprite = Sprite.new
          sprite.bitmap = Bitmap.new(width, height)
          sprite.x = self.x + x + 16
          sprite.y = self.y + y + 42 - height
          sprite.z = self.z + 1
          count = rand(400)
          # •Ãâ€rate‚É Œ»Ã‚ÌHP/MHP‚ð‘ã“ü
          if actor.maxsp != 0
                rate = ((width - 4) * actor.sp.to_f / actor.maxsp).ceil
          else
                rate = width - 4
          end
          # ˆÊ’u“™î•ñ‚Ì‹L‰¯
          @sp_gauge[actor] = [sprite, actor, rate, count, x, y - height]
          # ƒQ[ƒW•`‰æ
          gauge_refresh(@sp_gauge[actor], 1)
          # Æ’^[Æ’QÆ’bÆ’gÆ’EÆ’Bƒ“ƒhÆ’E‚Ìê‡A‰Šúó‘Ô‚Ãâ€Ã±â€¢\Ž¦
          @sp_gauge[actor][0].visible = false if self.is_a?(Window_Target)
        end
        # •Ãâ€rate‚É Œ»Ã‚ÌHP/MHP‚ð‘ã“ü
        if actor.maxsp != 0
          rate = ((width - 4) * actor.sp.to_f / actor.maxsp).ceil
        else
          rate = width - 4
        end
        @sp_gauge[actor][2] = rate
        # ƒIƒŠƒWƒiƒ‹‚ÌHP•`‰æˆ—‚ðŒÄ‚Ño‚µ
        draw_actor_sp_hpsp(actor, x, y, width)
  end
  #--------------------------------------------------------------------------
  # * Drawing of gauge
  #--------------------------------------------------------------------------
  def gauge_rect(width, height, color1, color2, color3, color4)
        bitmap = Bitmap.new(width, height)
        # ˜g•`‰æ
        bitmap.fill_rect(0, 0, width, height, color1)
        bitmap.fill_rect(1, 1, width - 2, height - 2, color2)
        # ‹óƒQ[ƒW‚Ì•`‰æ
        bitmap.gradation_rect(2, 2, width-4, height-4, color3, color4, 1)
        return bitmap
  end
  #--------------------------------------------------------------------------
  # œ ŽÀƒQ[ƒW‚ÌXV
  #--------------------------------------------------------------------------
  def gauge_refresh(gauge, type)
        # ƒ^ƒCƒv‚É‚æ‚蕪Šò
        case type
        when 0 # HPƒQ[ƒW‚Ìê‡
          graphic = RPG::Cache.system("Gauge_HP")
          rate = gauge[2] * 100 / (gauge[0].bitmap.width - 4)
          point = (rate < 50 ? 8 : 0) + (rate < 25 ? 8 : 0)
          frame = @hp_frame
        when 1 # SPƒQ[ƒW‚Ìê‡
          graphic = RPG::Cache.system("Gauge_SP")
          rate = gauge[2] * 100 / (gauge[0].bitmap.width - 4)
          point = (rate < 50 ? 8 : 0) + (rate < 25 ? 8 : 0)
          frame = @sp_frame
        end
        # ƒJƒEƒ“ƒg‚ÌXV
        gauge[3] = (gauge[3] - 2) % 400
        # ‹óƒQ[ƒW‚Ì‚Ì•`‰æ
        gauge[0].bitmap.fill_rect(0, 0, gauge[0].bitmap.width,
          gauge[0].bitmap.height, Color.new(0, 0, 0, 0))
        gauge[0].bitmap.blt(0, 0, frame, frame.rect)
        # Æ’Q[Æ’W‚Ì’†g‚ð•`‰æ‰Ââ€\‚Èê‡
        if gauge[2] > 0
          # ŽÀƒQ[ƒW‚Ì•`‰æ
          gauge[0].bitmap.blt(2, 2, graphic,
                Rect.new(gauge[3], point, gauge[2], gauge[0].bitmap.height - 4), 192)
          gauge[0].bitmap.fill_rect(3, 3, gauge[2] - 2,
                gauge[0].bitmap.height - 6,Color.new(0, 0, 0, 0))
          gauge[0].bitmap.blt(3, 3, graphic,
                Rect.new(gauge[3]+1,point+1,gauge[2]-2,gauge[0].bitmap.height- 6), 128)
        end
        # ƒQ[ƒWÀ•W‚ÌXV
        gauge[0].x = [self.x - self.ox + gauge[4] + 16, self.x + 16].max
        gauge[0].y = [self.y - self.oy + gauge[5] + 42, self.y + 16].max
        gauge[0].src_rect = Rect.new([self.ox - gauge[4], 0].max,
          [self.oy - gauge[5] - 26, 0].max,
          [self.ox + self.width - gauge[4] - 32, gauge[0].bitmap.width].min,
          [self.oy + self.height - gauge[5] - 32, gauge[0].bitmap.height].min)
        gauge[0].visible = self.visible
  end
  #--------------------------------------------------------------------------
  # Set X-position for gauge
  #--------------------------------------------------------------------------
  def x=(new_x)
        super(new_x)
        if @hp_gauge != nil
          # HP ƒQ[ƒW‚ÌXV
          for gauge in @hp_gauge.values + @sp_gauge.values
                gauge[0].x = self.x + gauge[4] + 16
          end
        end
  end
  #--------------------------------------------------------------------------
  # Set Y-position for gauge
  #--------------------------------------------------------------------------
  def y=(new_y)
        super(new_y)
        if @hp_gauge != nil
          # HP ƒQ[ƒW‚ÌXV
          for gauge in @hp_gauge.values + @sp_gauge.values
                gauge[0].y = self.y + gauge[5] + 42
          end
        end
  end
  #--------------------------------------------------------------------------
  # Set Z-depth for gauge
  #--------------------------------------------------------------------------
  def z=(new_z)
        super(new_z)
        if @hp_gauge != nil
          # HP ƒQ[ƒW‚ÌXV
          for gauge in @hp_gauge.values + @sp_gauge.values
                gauge[0].z = self.z + 1
          end
        end
  end
end


#==============================================================================
# ** Window_Help
#------------------------------------------------------------------------------
#  This window shows skill and item explanations along with actor status.
#==============================================================================

class Window_Help < Window_Base
  #--------------------------------------------------------------------------
  # * Set Text
  #  text  : text string displayed in window
  #  align : alignment (0..flush left, 1..center, 2..flush right)
  #--------------------------------------------------------------------------
  alias :gauge_set_text :set_text
  def set_text(text, align = 0)
        # Æ’eÆ’LÆ’XÆ’g‚ƃAƒ‰ƒCƒ“ƒƒ“ƒg‚Ì*‚È‚*‚Æ‚àˆê•û‚ª‘O‰ñ‚ƈá‚ÂĂ¢‚éê‡
        if text != @text or align != @align
          # ƒQ[ƒW‚Ìíœ
          gauge_delete
          # ƒIƒŠƒWƒiƒ‹‚̈—
          gauge_set_text(text, align)
        end
  end
  #--------------------------------------------------------------------------
  # * Set Actor
  #      actor : status displaying actor
  #--------------------------------------------------------------------------
  alias :gauge_set_actor :set_actor
  def set_actor(actor)
        if actor != @actor
          # ƒQ[ƒW‚Ìíœ
          gauge_delete
          # ƒIƒŠƒWƒiƒ‹‚̈—
          gauge_set_actor(actor)
        end
  end
  #--------------------------------------------------------------------------
  # * Set Enemy
  #      enemy : name and status displaying enemy
  #--------------------------------------------------------------------------
  alias :gauge_set_enemy :set_enemy
  def set_enemy(enemy)
        # ƒQ[ƒW‚Ìíœ
        gauge_delete
        # ƒIƒŠƒWƒiƒ‹‚̈—
        gauge_set_enemy(enemy)
  end
end


#==============================================================================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
#  This class brings together battle screen sprites. It's used within
#  the Scene_Battle class.
#==============================================================================

class Spriteset_Battle
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  alias :initialize_gauge :initialize
  def initialize
        initialize_gauge
        @viewport2.z = 100
  end
end

#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
# 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

#==============================================================================
# **  Sprite
#------------------------------------------------------------------------------
#  Class for sprites added to various effect handling used within RPGXP
#==============================================================================

module RPG
  class Sprite < ::Sprite
        def damage(value, critical)
          dispose_damage
          if value.is_a?(Numeric)
                damage_string = value.abs.to_s
          else
                damage_string = value.to_s
          end
          bitmap = Bitmap.new(160, 48)
          bitmap.font.name = "Arial Black"
          bitmap.font.size = 32
          bitmap.font.color.set(0, 0, 0)
          bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
          bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
          bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
          bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
          if value.is_a?(Numeric) and value < 0
                bitmap.font.color.set(176, 255, 144)
          else
                bitmap.font.color.set(255, 255, 255)
          end
          bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
          if critical
                bitmap.font.size = 20
                bitmap.font.color.set(0, 0, 0)
                bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
                bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
                bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
                bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
                bitmap.font.color.set(255, 255, 255)
                bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
          end
          @_damage_sprite = ::Sprite.new
          @_damage_sprite.bitmap = bitmap
          @_damage_sprite.ox = 80 + self.viewport.ox
          @_damage_sprite.oy = 20 + self.viewport.oy
          @_damage_sprite.x = self.x + self.viewport.rect.x
          @_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
          @_damage_sprite.z = 3000
          @_damage_duration = 40
        end
        def animation(animation, hit)
          dispose_animation
          @_animation = animation
          return if @_animation == nil
          @_animation_hit = hit
          @_animation_duration = @_animation.frame_max
          animation_name = @_animation.animation_name
          animation_hue = @_animation.animation_hue
          bitmap = RPG::Cache.animation(animation_name, animation_hue)
          if @@_reference_count.include?(bitmap)
                @@_reference_count[bitmap] += 1
          else
                @@_reference_count[bitmap] = 1
          end
          @_animation_sprites = []
          if @_animation.position != 3 or not @@_animations.include?(animation)
                for i in 0..15
                  sprite = ::Sprite.new
                  sprite.bitmap = bitmap
                  sprite.visible = false
                  @_animation_sprites.push(sprite)
                end
                unless @@_animations.include?(animation)
                  @@_animations.push(animation)
                end
          end
          update_animation
        end
        def loop_animation(animation)
          return if animation == @_loop_animation
          dispose_loop_animation
          @_loop_animation = animation
          return if @_loop_animation == nil
          @_loop_animation_index = 0
          animation_name = @_loop_animation.animation_name
          animation_hue = @_loop_animation.animation_hue
          bitmap = RPG::Cache.animation(animation_name, animation_hue)
          if @@_reference_count.include?(bitmap)
                @@_reference_count[bitmap] += 1
          else
                @@_reference_count[bitmap] = 1
          end
          @_loop_animation_sprites = []
          for i in 0..15
                sprite = ::Sprite.new
                sprite.bitmap = bitmap
                sprite.visible = false
                @_loop_animation_sprites.push(sprite)
          end
          update_loop_animation
        end
        def animation_set_sprites(sprites, cell_data, position)
          for i in 0..15
                sprite = sprites[i]
                pattern = cell_data[i, 0]
                if sprite == nil or pattern == nil or pattern == -1
                  sprite.visible = false if sprite != nil
                  next
                end
                sprite.visible = true
                sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
                if position == 3
                  if self.viewport != nil
                        sprite.x = self.viewport.rect.width / 2
                        sprite.y = self.viewport.rect.height - 160
                  else
                        sprite.x = 320
                        sprite.y = 240
                  end
                else
                  sprite.x = self.x + self.viewport.rect.x -
                                          self.ox + self.src_rect.width / 2
                  sprite.y = self.y + self.viewport.rect.y -
                                          self.oy + self.src_rect.height / 2
                  sprite.y -= self.src_rect.height / 4 if position == 0
                  sprite.y += self.src_rect.height / 4 if position == 2
                end
                sprite.x += cell_data[i, 1]
                sprite.y += cell_data[i, 2]
                sprite.z = 2000
                sprite.ox = 96
                sprite.oy = 96
                sprite.zoom_x = cell_data[i, 3] / 100.0
                sprite.zoom_y = cell_data[i, 3] / 100.0
                sprite.angle = cell_data[i, 4]
                sprite.mirror = (cell_data[i, 5] == 1)
                sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
                sprite.blend_type = cell_data[i, 7]
          end
        end
  end
end


#==============================================================================
# ** RPG
#------------------------------------------------------------------------------
# A module containing RPGXP's data structures and more.
#==============================================================================

module RPG
  #============================================================================
  # ** Cache
  #----------------------------------------------------------------------------
  # A module that loads each of RPGXP's graphic formats, creates a Bitmap
  # object, and retains it.
  #============================================================================
  module Cache
        def self.system(filename)
          self.load_bitmap("Graphics/Pictures/", filename)
        end
  end
end

 

thanks

Share this post

Link to post
Share on other sites

0 answers to this question

Recommended Posts

There have been no answers to this question yet

Please sign in to comment

You will be able to leave a comment after signing in



Sign In Now
Go To Question Listing

  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...