rmxp_extractor 1.7 → 1.8

data/Scripts/Sprite_Battler.rb

@@ -0,0 +1,131 @@
+#==============================================================================
+# ** Sprite_Battler
+#------------------------------------------------------------------------------
+#  This sprite is used to display the battler.It observes the Game_Character
+#  class and automatically changes sprite conditions.
+#==============================================================================
+
+class Sprite_Battler < RPG::Sprite
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_accessor :battler                  # battler
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #     viewport : viewport
+  #     battler  : battler (Game_Battler)
+  #--------------------------------------------------------------------------
+  def initialize(viewport, battler = nil)
+    super(viewport)
+    @battler = battler
+    @battler_visible = false
+  end
+  #--------------------------------------------------------------------------
+  # * Dispose
+  #--------------------------------------------------------------------------
+  def dispose
+    if self.bitmap != nil
+      self.bitmap.dispose
+    end
+    super
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    super
+    # If battler is nil
+    if @battler == nil
+      self.bitmap = nil
+      loop_animation(nil)
+      return
+    end
+    # If file name or hue are different than current ones
+    if @battler.battler_name != @battler_name or
+       @battler.battler_hue != @battler_hue
+      # Get and set bitmap
+      @battler_name = @battler.battler_name
+      @battler_hue = @battler.battler_hue
+      self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
+      @width = bitmap.width
+      @height = bitmap.height
+      self.ox = @width / 2
+      self.oy = @height
+      # Change opacity level to 0 when dead or hidden
+      if @battler.dead? or @battler.hidden
+        self.opacity = 0
+      end
+    end
+    # If animation ID is different than current one
+    if @battler.damage == nil and
+       @battler.state_animation_id != @state_animation_id
+      @state_animation_id = @battler.state_animation_id
+      loop_animation($data_animations[@state_animation_id])
+    end
+    # If actor which should be displayed
+    if @battler.is_a?(Game_Actor) and @battler_visible
+      # Bring opacity level down a bit when not in main phase
+      if $game_temp.battle_main_phase
+        self.opacity += 3 if self.opacity < 255
+      else
+        self.opacity -= 3 if self.opacity > 207
+      end
+    end
+    # Blink
+    if @battler.blink
+      blink_on
+    else
+      blink_off
+    end
+    # If invisible
+    unless @battler_visible
+      # Appear
+      if not @battler.hidden and not @battler.dead? and
+         (@battler.damage == nil or @battler.damage_pop)
+        appear
+        @battler_visible = true
+      end
+    end
+    # If visible
+    if @battler_visible
+      # Escape
+      if @battler.hidden
+        $game_system.se_play($data_system.escape_se)
+        escape
+        @battler_visible = false
+      end
+      # White flash
+      if @battler.white_flash
+        whiten
+        @battler.white_flash = false
+      end
+      # Animation
+      if @battler.animation_id != 0
+        animation = $data_animations[@battler.animation_id]
+        animation(animation, @battler.animation_hit)
+        @battler.animation_id = 0
+      end
+      # Damage
+      if @battler.damage_pop
+        damage(@battler.damage, @battler.critical)
+        @battler.damage = nil
+        @battler.critical = false
+        @battler.damage_pop = false
+      end
+      # Collapse
+      if @battler.damage == nil and @battler.dead?
+        if @battler.is_a?(Game_Enemy)
+          $game_system.se_play($data_system.enemy_collapse_se)
+        else
+          $game_system.se_play($data_system.actor_collapse_se)
+        end
+        collapse
+        @battler_visible = false
+      end
+    end
+    # Set sprite coordinates
+    self.x = @battler.screen_x
+    self.y = @battler.screen_y
+    self.z = @battler.screen_z
+  end
+end

data/Scripts/Sprite_Character.rb

@@ -0,0 +1,192 @@
+#==============================================================================
+# ** Sprite_Character
+#------------------------------------------------------------------------------
+#  This sprite is used to display the character.It observes the Game_Character
+#  class and automatically changes sprite conditions.
+#==============================================================================
+
+class Sprite_Character
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_accessor :character                # character
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #     viewport       : viewport
+  #     light_viewport : light viewport
+  #     character      : character (Game_Character)
+  #--------------------------------------------------------------------------
+  def initialize(viewport, light_viewport, character = nil)
+    @viewport = viewport
+    @light_viewport = light_viewport
+    @sprite = RPG::Sprite.new(viewport)
+    @light_sprite = RPG::Sprite.new(light_viewport)
+    @light_sprite.blend_type = 1
+    @character = character
+    update
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    # Choose the appropriate light sprite
+    @light_sprite.viewport = ($game_screen.tone.blank?) ? @viewport : @light_viewport
+    # Update sprites
+    @sprite.update
+    @light_sprite.update
+    # If tile ID, file name, or hue are different from current ones
+    if @tile_id != @character.tile_id or
+       @character_name != @character.character_name or
+       @character_hue != @character.character_hue
+      # Remember tile ID, file name, and hue
+      @tile_id = @character.tile_id
+      @character_name = @character.character_name
+      @character_hue = @character.character_hue
+      # If tile ID value is valid
+      if @tile_id >= 384
+        @sprite.bitmap = RPG::Cache.tile($game_map.tileset_name,
+          @tile_id, @character.character_hue)
+        @light_sprite.visible = false
+        @sprite.src_rect.set(0, 0, 32, 32)
+        @light_sprite.src_rect.set(0, 0, 32, 32)
+        self.ox = 16
+        self.oy = 32
+      # If tile ID value is invalid
+      else
+        @sprite.bitmap = RPG::Cache.character(@character.character_name,
+          @character.character_hue)
+        begin
+          @light_sprite.bitmap = RPG::Cache.lightmap(@character.character_name)
+          @light_sprite.visible = true
+        rescue
+          @light_sprite.bitmap = nil
+          @light_sprite.visible = false
+        end
+        @cw = @sprite.bitmap.width / 4
+        @ch = @sprite.bitmap.height / 4
+        self.ox = @cw / 2
+        self.oy = @ch
+      end
+    end
+    # Set visible situation
+    self.visible = (not @character.transparent)
+    # If graphic is character
+    if @tile_id == 0
+      # Set rectangular transfer
+      sx = @character.pattern * @cw
+      sy = (@character.direction - 2) / 2 * @ch
+      @sprite.src_rect.set(sx, sy, @cw, @ch)
+      @light_sprite.src_rect.set(sx, sy, @cw, @ch)
+    end
+    # Set sprite coordinates
+    self.x = @character.screen_x
+    self.y = @character.screen_y
+    self.z = @character.screen_z(@ch)
+    # Set opacity level, blend method, and bush depth
+    self.opacity = @character.opacity
+    self.blend_type = @character.blend_type
+    self.bush_depth = @character.bush_depth
+    # Animation
+    if @character.animation_id != 0
+      animation = $data_animations[@character.animation_id]
+      animation(animation, true)
+      @character.animation_id = 0
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update Fast (only position)
+  #--------------------------------------------------------------------------
+  def update_fast
+    # Set sprite coordinates
+    self.x = @character.screen_x
+    self.y = @character.screen_y
+    self.z = @character.screen_z(@ch)
+  end
+  #--------------------------------------------------------------------------
+  # * Sprite attribute wrapper
+  #--------------------------------------------------------------------------
+  def self.sprite_attr(*args)
+    args.each do |arg|
+      class_eval("def #{arg};@sprite.#{arg};end")
+      class_eval("def #{arg}=(val);@sprite.#{arg}=val;@light_sprite.#{arg}=val;end")
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * RPG::Sprite methods
+  #--------------------------------------------------------------------------
+  def whiten
+    @sprite.whiten
+    @light_sprite.whiten
+  end
+  def appear
+    @sprite.appear
+    @light_sprite.appear
+  end
+  def escape
+    @sprite.escape
+    @light_sprite.escape
+  end
+  def collapse
+    @sprite.collapse
+    @light_sprite.collapse
+  end
+  def damage(value, critical)
+    @sprite.damage(value, critical)
+  end
+  def animation(animation, hit)
+    @sprite.animation(animation, hit)
+  end
+  def loop_animation(animation, hit)
+    @sprite.loop_animation(animation)
+  end
+  def blink_on
+    @sprite.blink_on
+    @light_sprite.blink_on
+  end
+  def blink_off
+    @sprite.blink_off
+    @light_sprite.blink_off
+  end
+  def blink?
+    @sprite.blink?
+  end
+  def effect?
+    @sprite.effect?
+  end
+  #--------------------------------------------------------------------------
+  # * Sprite methods
+  #--------------------------------------------------------------------------
+  def dispose
+    @sprite.dispose
+    @light_sprite.dispose
+    @sprite = nil
+    @light_sprite = nil
+  end
+  def disposed?
+    @sprite == nil
+  end
+  def flash(color, duration)
+    @sprite.flash(color, duration)
+    @light_sprite.flash(color, duration)
+  end
+  #--------------------------------------------------------------------------
+  # * Sprite properties
+  #--------------------------------------------------------------------------
+  sprite_attr :src_rect
+  sprite_attr :visible
+  sprite_attr :x, :y, :z
+  sprite_attr :ox, :oy
+  sprite_attr :zoom_x, :zoom_y
+  sprite_attr :angle
+  sprite_attr :mirror
+  sprite_attr :bush_depth
+  sprite_attr :opacity
+  sprite_attr :color
+  sprite_attr :tone
+  def blend_type
+    @sprite.blend_type
+  end
+  def blend_type=(val)
+    @sprite.blend_type = val
+  end
+end

data/Scripts/Sprite_Footprint.rb

@@ -0,0 +1,35 @@
+class Sprite_Footprint < Sprite
+  def initialize(viewport, direction, x, y)
+    super(viewport)
+    @direction = direction
+    @real_x = x * 4 * 32
+    @real_y = y * 4 * 32
+
+    self.zoom_x = 2
+    self.zoom_y = 2
+    self.ox = 8
+    self.oy = 16
+    self.bitmap = RPG::Cache.misc('footprints')
+    self.src_rect.set(0, 16 * (direction / 2 - 1), 16, 16)
+    update
+  end
+
+  def update
+    return if disposed?
+
+    self.x = (@real_x - $game_map.display_x + 3) / 4 + 16
+    self.y = (@real_y - $game_map.display_y + 3) / 4 + 32
+
+    self.opacity -= 4
+    if self.opacity == 0
+      dispose
+    end
+  end
+
+  def correctX(xDelta)
+    @real_x += xDelta*4*32
+  end
+  def correctY(yDelta)
+    @real_y += yDelta*4*32
+  end
+end

data/Scripts/Sprite_Footsplash.rb

@@ -0,0 +1,54 @@
+class Sprite_Footsplash < Sprite
+  def initialize(viewport, direction, x, y)
+
+    super(viewport)
+    y = y + 2
+    @direction = direction
+    @real_x = x * 4 * 32
+    @real_y = y * 4 * 32
+
+    case direction
+    when 2
+      @real_y -= 32
+    when 4
+      @real_x += 32
+    when 6
+      @real_x -= 32
+    when 8
+      @real_y += 32
+    end
+
+    @real_y += 48
+
+    self.zoom_x = 2
+    self.zoom_y = 2
+    self.ox = 40
+    self.oy = 80
+    self.bitmap = RPG::Cache.misc('foot_splash')
+    self.src_rect.set(0, 0, 80, 80)
+    update
+  end
+
+  def update
+    return if disposed?
+
+    self.x = (@real_x - $game_map.display_x + 3) / 4 + 16
+    self.y = (@real_y - $game_map.display_y + 3) / 4 + 32
+
+    self.opacity -= 6
+    frameIndex = 20 - (self.opacity / 13)
+    frameX = frameIndex % 4
+    frameY = frameIndex / 4
+    self.src_rect.set(80*frameX, 80*frameY, 80, 80)
+    if self.opacity == 0
+      dispose
+    end
+  end
+
+  def correctX(xDelta)
+    @real_x += xDelta*4*32
+  end
+  def correctY(yDelta)
+    @real_y += yDelta*4*32
+  end
+end

data/Scripts/Sprite_Light.rb

@@ -0,0 +1,18 @@
+# A scene lightmap object
+class Light < RPG::Sprite
+  def initialize(viewport, filename, intensity, x, y)
+    super(viewport)
+    self.lightmap = RPG::Cache.light(filename)
+    self.intensity = intensity
+    @map_x = x
+    @map_y = y
+    self.z = 9999
+    self.visible = true
+    update
+  end
+
+  def update
+    self.x = @map_x - $game_map.display_x / 4
+    self.y = @map_y - $game_map.display_y / 4
+  end
+end

data/Scripts/Sprite_MapText.rb

@@ -0,0 +1,63 @@
+class Sprite_MapText < Sprite
+
+  def initialize(viewport, text, x, y)
+
+    super(viewport)
+	@direction = 2
+    @real_x = x * 4 * 32
+    @real_y = y * 4 * 32
+
+    self.bitmap = Bitmap.new(200, 24)
+    if (Language::FONT_WESTERN == Font.default_name)
+      self.zoom_x = 2
+      self.zoom_y = 2
+    else
+      self.zoom_x = 1.5
+      self.zoom_y = 1.5
+    end
+
+	#calculate text width
+    spacewidth = self.bitmap.text_size(' ').width
+	width = 0
+
+	text.split(' ').each do |word|
+
+      # Get width of this word
+      width += self.bitmap.text_size(word.gsub(/(\000\[[0-9]+\]|\001|\002)/, '')).width
+      width += spacewidth
+    end
+    width -= spacewidth
+
+    if width <= 0
+      width = 1
+    end
+
+	self.bitmap.dispose
+	self.bitmap = Bitmap.new(width, 24)
+	self.bitmap.font.color = Color.new(81, 33, 129, 255)
+	self.bitmap.draw_text(0,0, width, 24, text)
+
+    self.src_rect.set(0, 0, width, 24)
+    self.oy = 24
+    self.ox = width/2
+
+
+    update
+  end
+
+  def update
+    return if disposed?
+
+    self.x = (@real_x - $game_map.display_x + 3) / 4 + 16
+    self.y = (@real_y - $game_map.display_y + 3) / 4 + 32
+
+  end
+
+  def correctX(xDelta)
+    #do nothing
+  end
+  def correctY(yDelta)
+    #do nothing
+  end
+
+end

data/Scripts/Sprite_Picture.rb

@@ -0,0 +1,72 @@
+#==============================================================================
+# ** Sprite_Picture
+#------------------------------------------------------------------------------
+#  This sprite is used to display the picture.It observes the Game_Character
+#  class and automatically changes sprite conditions.
+#==============================================================================
+
+class Sprite_Picture < Sprite
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #     viewport : viewport
+  #     picture  : picture (Game_Picture)
+  #--------------------------------------------------------------------------
+  def initialize(viewport, picture)
+    super(viewport)
+    @picture = picture
+    update
+  end
+  #--------------------------------------------------------------------------
+  # * Dispose
+  #--------------------------------------------------------------------------
+  def dispose
+    if self.bitmap != nil
+      self.bitmap.dispose
+    end
+    super
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    super
+    # If picture file name is different from current one
+    if @picture_name != @picture.name
+      # Remember file name to instance variables
+      @picture_name = @picture.name
+      # If file name is not empty
+      if @picture_name != ""
+        # Get picture graphic
+        self.bitmap = RPG::Cache.picture(@picture_name)
+      end
+    end
+    # If file name is empty
+    if @picture_name == ""
+      # Set sprite to invisible
+      self.visible = false
+      return
+    end
+    # Set sprite to visible
+    self.visible = true
+    # Set transfer starting point
+    if @picture.origin == 0
+      self.ox = 0
+      self.oy = 0
+    else
+      self.ox = self.bitmap.width / 2
+      self.oy = self.bitmap.height / 2
+    end
+    # Set sprite coordinates
+    self.x = @picture.x
+    self.y = @picture.y
+    self.z = @picture.number
+    # Set zoom rate, opacity level, and blend method
+    self.zoom_x = @picture.zoom_x / 100.0
+    self.zoom_y = @picture.zoom_y / 100.0
+    self.opacity = @picture.opacity
+    self.blend_type = @picture.blend_type
+    # Set rotation angle and color tone
+    self.angle = @picture.angle
+    self.tone = @picture.tone
+  end
+end

data/Scripts/Sprite_Timer.rb

@@ -0,0 +1,52 @@
+#==============================================================================
+# ** Sprite_Timer
+#------------------------------------------------------------------------------
+#  This sprite is used to display the timer.It observes the $game_system
+#  class and automatically changes sprite conditions.
+#==============================================================================
+
+class Sprite_Timer < Sprite
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    super
+    self.bitmap = Bitmap.new(88, 48)
+    self.bitmap.font.size = 32
+    self.x = 640 - self.bitmap.width
+    self.y = 0
+    self.z = 500
+    update
+  end
+  #--------------------------------------------------------------------------
+  # * Dispose
+  #--------------------------------------------------------------------------
+  def dispose
+    if self.bitmap != nil
+      self.bitmap.dispose
+    end
+    super
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    super
+    # Set timer to visible if working
+    self.visible = $game_system.timer_working
+    # If timer needs to be redrawn
+    if $game_system.timer / Graphics.frame_rate != @total_sec
+      # Clear window contents
+      self.bitmap.clear
+      # Calculate total number of seconds
+      @total_sec = $game_system.timer / Graphics.frame_rate
+      # Make a string for displaying the timer
+      min = @total_sec / 60
+      sec = @total_sec % 60
+      text = sprintf("%02d:%02d", min, sec)
+      # Draw timer
+      self.bitmap.font.color.set(255, 255, 255)
+      self.bitmap.draw_text(self.bitmap.rect, text, 1)
+    end
+  end
+end