rmxp_extractor 1.8 → 2.0.0

data/Scripts/Sprite_Battler.rb

@@ -1,131 +0,0 @@
-#==============================================================================
-# ** 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

@@ -1,192 +0,0 @@
-#==============================================================================
-# ** 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

@@ -1,35 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,18 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-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

@@ -1,72 +0,0 @@
-#==============================================================================
-# ** 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

@@ -1,52 +0,0 @@
-#==============================================================================
-# ** 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