rmxp_extractor 1.8 → 1.9

data/Scripts/Game_Party.rb

@@ -1,380 +0,0 @@
-#==============================================================================
-# ** Game_Party
-#------------------------------------------------------------------------------
-#  This class handles the party. It includes information on amount of gold
-#  and items. Refer to "$game_party" for the instance of this class.
-#==============================================================================
-
-class Game_Party
-  #--------------------------------------------------------------------------
-  # * Public Instance Variables
-  #--------------------------------------------------------------------------
-  attr_reader   :actors                   # actors
-  attr_reader   :gold                     # amount of gold
-  attr_reader   :steps                    # number of steps
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #--------------------------------------------------------------------------
-  def initialize
-    # Create actor array
-    @actors = []
-    # Initialize amount of gold and steps
-    @gold = 0
-    @steps = 0
-    # Create amount in possession hash for items, weapons, and armor
-    @items = {}
-    @weapons = {}
-    @armors = {}
-  end
-  #--------------------------------------------------------------------------
-  # * Initial Party Setup
-  #--------------------------------------------------------------------------
-  def setup_starting_members
-    @actors = []
-    for i in $data_system.party_members
-      #@actors.push($game_actors[i])
-      add_actor(i)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Battle Test Party Setup
-  #--------------------------------------------------------------------------
-  def setup_battle_test_members
-    @actors = []
-    for battler in $data_system.test_battlers
-      actor = $game_actors[battler.actor_id]
-      actor.level = battler.level
-      gain_weapon(battler.weapon_id, 1)
-      gain_armor(battler.armor1_id, 1)
-      gain_armor(battler.armor2_id, 1)
-      gain_armor(battler.armor3_id, 1)
-      gain_armor(battler.armor4_id, 1)
-      actor.equip(0, battler.weapon_id)
-      actor.equip(1, battler.armor1_id)
-      actor.equip(2, battler.armor2_id)
-      actor.equip(3, battler.armor3_id)
-      actor.equip(4, battler.armor4_id)
-      actor.recover_all
-      @actors.push(actor)
-    end
-    @items = {}
-    for i in 1...$data_items.size
-      if $data_items[i].name != ""
-        occasion = $data_items[i].occasion
-        if occasion == 0 or occasion == 1
-          @items[i] = 99
-        end
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Refresh Party Members
-  #--------------------------------------------------------------------------
-  def refresh
-    # Actor objects split from $game_actors right after loading game data
-    # Avoid this problem by resetting the actors each time data is loaded.
-    new_actors = []
-    for i in 0...@actors.size
-      if $data_actors[@actors[i].id] != nil
-        new_actors.push($game_actors[@actors[i].id])
-      end
-    end
-    @actors = new_actors
-  end
-  #--------------------------------------------------------------------------
-  # * Getting Maximum Level
-  #--------------------------------------------------------------------------
-  def max_level
-    # If 0 members are in the party
-    if @actors.size == 0
-      return 0
-    end
-    # Initialize local variable: level
-    level = 0
-    # Get maximum level of party members
-    for actor in @actors
-      if level < actor.level
-        level = actor.level
-      end
-    end
-    return level
-  end
-  #--------------------------------------------------------------------------
-  # * Add an Actor
-  #     actor_id : actor ID
-  #--------------------------------------------------------------------------
-  def add_actor(actor_id)
-    # Get actor
-    actor = $game_actors[actor_id]
-    # If the party has less than 4 members and this actor is not in the party
-    if @actors.size < 4 and not @actors.include?(actor)
-      # Add follower
-      unless @actors.empty?
-        if $game_followers.empty?
-          $game_followers.push(Game_Follower.new($game_player, actor))
-        else
-          $game_followers.push(Game_Follower.new($game_followers.last, actor))
-        end
-        $scene.add_follower($game_followers.last)
-      end
-      # Add actor
-      @actors.push(actor)
-      # Refresh player
-      $game_player.refresh
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Remove Actor
-  #     actor_id : actor ID
-  #--------------------------------------------------------------------------
-  def remove_actor(actor_id)
-    actor = $game_actors[actor_id]
-    # Delete follower
-    unless $game_followers.empty?
-      follower = $game_followers.pop
-      $scene.remove_follower(follower)
-      new_actor = follower.actor
-	  if new_actor != actor
-        $game_followers.reverse_each do |follower|
-          new_actor, follower.actor = follower.actor, new_actor
-          break if new_actor == actor
-        end
-	  end
-    end
-    # Delete actor
-    @actors.delete(actor)
-    # Refresh player
-    # $game_player.refresh
-  end
-  #--------------------------------------------------------------------------
-  # * Gain Gold (or lose)
-  #     n : amount of gold
-  #--------------------------------------------------------------------------
-  def gain_gold(n)
-    @gold = [[@gold + n, 0].max, 9999999].min
-  end
-  #--------------------------------------------------------------------------
-  # * Lose Gold
-  #     n : amount of gold
-  #--------------------------------------------------------------------------
-  def lose_gold(n)
-    # Reverse the numerical value and call it gain_gold
-    gain_gold(-n)
-  end
-  #--------------------------------------------------------------------------
-  # * Increase Steps
-  #--------------------------------------------------------------------------
-  def increase_steps
-    @steps = [@steps + 1, 9999999].min
-  end
-  #--------------------------------------------------------------------------
-  # * Get Number of Items Possessed
-  #     item_id : item ID
-  #--------------------------------------------------------------------------
-  def item_number(item_id)
-    # If quantity data is in the hash, use it. If not, return 0
-    return @items.include?(item_id) ? @items[item_id] : 0
-  end
-  #--------------------------------------------------------------------------
-  # * Get Number of Weapons Possessed
-  #     weapon_id : weapon ID
-  #--------------------------------------------------------------------------
-  def weapon_number(weapon_id)
-    # If quantity data is in the hash, use it. If not, return 0
-    return @weapons.include?(weapon_id) ? @weapons[weapon_id] : 0
-  end
-  #--------------------------------------------------------------------------
-  # * Get Amount of Armor Possessed
-  #     armor_id : armor ID
-  #--------------------------------------------------------------------------
-  def armor_number(armor_id)
-    # If quantity data is in the hash, use it. If not, return 0
-    return @armors.include?(armor_id) ? @armors[armor_id] : 0
-  end
-  #--------------------------------------------------------------------------
-  # * Gain Items (or lose)
-  #     item_id : item ID
-  #     n       : quantity
-  #--------------------------------------------------------------------------
-  def gain_item(item_id, n)
-    # Update quantity data in the hash.
-    if item_id > 0
-      @items[item_id] = [[item_number(item_id) + n, 0].max, 99].min
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Gain Weapons (or lose)
-  #     weapon_id : weapon ID
-  #     n         : quantity
-  #--------------------------------------------------------------------------
-  def gain_weapon(weapon_id, n)
-    # Update quantity data in the hash.
-    if weapon_id > 0
-      @weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, 99].min
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Gain Armor (or lose)
-  #     armor_id : armor ID
-  #     n        : quantity
-  #--------------------------------------------------------------------------
-  def gain_armor(armor_id, n)
-    # Update quantity data in the hash.
-    if armor_id > 0
-      @armors[armor_id] = [[armor_number(armor_id) + n, 0].max, 99].min
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Lose Items
-  #     item_id : item ID
-  #     n       : quantity
-  #--------------------------------------------------------------------------
-  def lose_item(item_id, n)
-    # Reverse the numerical value and call it gain_item
-    gain_item(item_id, -n)
-  end
-  #--------------------------------------------------------------------------
-  # * Lose Weapons
-  #     weapon_id : weapon ID
-  #     n         : quantity
-  #--------------------------------------------------------------------------
-  def lose_weapon(weapon_id, n)
-    # Reverse the numerical value and call it gain_weapon
-    gain_weapon(weapon_id, -n)
-  end
-  #--------------------------------------------------------------------------
-  # * Lose Armor
-  #     armor_id : armor ID
-  #     n        : quantity
-  #--------------------------------------------------------------------------
-  def lose_armor(armor_id, n)
-    # Reverse the numerical value and call it gain_armor
-    gain_armor(armor_id, -n)
-  end
-  #--------------------------------------------------------------------------
-  # * Determine if Item is Usable
-  #     item_id : item ID
-  #--------------------------------------------------------------------------
-  def item_can_use?(item_id)
-    # If item quantity is 0
-    if item_number(item_id) == 0
-      # Unusable
-      return false
-    end
-    # Get usable time
-    occasion = $data_items[item_id].occasion
-    # If in battle
-    if $game_temp.in_battle
-      # If useable time is 0 (normal) or 1 (only battle) it's usable
-      return (occasion == 0 or occasion == 1)
-    end
-    # If useable time is 0 (normal) or 2 (only menu) it's usable
-    return (occasion == 0 or occasion == 2)
-  end
-  #--------------------------------------------------------------------------
-  # * Clear All Member Actions
-  #--------------------------------------------------------------------------
-  def clear_actions
-    # Clear All Member Actions
-    for actor in @actors
-      actor.current_action.clear
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Determine if Command is Inputable
-  #--------------------------------------------------------------------------
-  def inputable?
-    # Return true if input is possible for one person as well
-    for actor in @actors
-      if actor.inputable?
-        return true
-      end
-    end
-    return false
-  end
-  #--------------------------------------------------------------------------
-  # * Determine Everyone is Dead
-  #--------------------------------------------------------------------------
-  def all_dead?
-    # If number of party members is 0
-    if $game_party.actors.size == 0
-      return false
-    end
-    # If an actor is in the party with 0 or more HP
-    for actor in @actors
-      if actor.hp > 0
-        return false
-      end
-    end
-    # All members dead
-    return true
-  end
-  #--------------------------------------------------------------------------
-  # * Slip Damage Check (for map)
-  #--------------------------------------------------------------------------
-  def check_map_slip_damage
-    for actor in @actors
-      if actor.hp > 0 and actor.slip_damage?
-        actor.hp -= [actor.maxhp / 100, 1].max
-        if actor.hp == 0
-          $game_system.se_play($data_system.actor_collapse_se)
-        end
-        $game_screen.start_flash(Color.new(255,0,0,128), 4)
-        $game_temp.gameover = $game_party.all_dead?
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Random Selection of Target Actor
-  #     hp0 : limited to actors with 0 HP
-  #--------------------------------------------------------------------------
-  def random_target_actor(hp0 = false)
-    # Initialize roulette
-    roulette = []
-    # Loop
-    for actor in @actors
-      # If it fits the conditions
-      if (not hp0 and actor.exist?) or (hp0 and actor.hp0?)
-        # Get actor class [position]
-        position = $data_classes[actor.class_id].position
-        # Front guard: n = 4; Mid guard: n = 3; Rear guard: n = 2
-        n = 4 - position
-        # Add actor to roulette n times
-        n.times do
-          roulette.push(actor)
-        end
-      end
-    end
-    # If roulette size is 0
-    if roulette.size == 0
-      return nil
-    end
-    # Spin the roulette, choose an actor
-    return roulette[rand(roulette.size)]
-  end
-  #--------------------------------------------------------------------------
-  # * Random Selection of Target Actor (HP 0)
-  #--------------------------------------------------------------------------
-  def random_target_actor_hp0
-    return random_target_actor(true)
-  end
-  #--------------------------------------------------------------------------
-  # * Smooth Selection of Target Actor
-  #     actor_index : actor index
-  #--------------------------------------------------------------------------
-  def smooth_target_actor(actor_index)
-    # Get an actor
-    actor = @actors[actor_index]
-    # If an actor exists
-    if actor != nil and actor.exist?
-      return actor
-    end
-    # Loop
-    for actor in @actors
-      # If an actor exists
-      if actor.exist?
-        return actor
-      end
-    end
-  end
-end

data/Scripts/Game_Picture.rb

@@ -1,164 +0,0 @@
-#==============================================================================
-# ** Game_Picture
-#------------------------------------------------------------------------------
-#  This class handles the picture. It's used within the Game_Screen class
-#  ($game_screen).
-#==============================================================================
-
-class Game_Picture
-  #--------------------------------------------------------------------------
-  # * Public Instance Variables
-  #--------------------------------------------------------------------------
-  attr_reader   :number                   # picture number
-  attr_reader   :name                     # file name
-  attr_reader   :origin                   # starting point
-  attr_reader   :x                        # x-coordinate
-  attr_reader   :y                        # y-coordinate
-  attr_reader   :zoom_x                   # x directional zoom rate
-  attr_reader   :zoom_y                   # y directional zoom rate
-  attr_reader   :opacity                  # opacity level
-  attr_reader   :blend_type               # blend method
-  attr_reader   :tone                     # color tone
-  attr_reader   :angle                    # rotation angle
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #     number : picture number
-  #--------------------------------------------------------------------------
-  def initialize(number)
-    @number = number
-    @name = ""
-    @origin = 0
-    @x = 0.0
-    @y = 0.0
-    @zoom_x = 100.0
-    @zoom_y = 100.0
-    @opacity = 255.0
-    @blend_type = 1
-    @duration = 0
-    @target_x = @x
-    @target_y = @y
-    @target_zoom_x = @zoom_x
-    @target_zoom_y = @zoom_y
-    @target_opacity = @opacity
-    @tone = Tone.new(0, 0, 0, 0)
-    @tone_target = Tone.new(0, 0, 0, 0)
-    @tone_duration = 0
-    @angle = 0
-    @rotate_speed = 0
-  end
-  #--------------------------------------------------------------------------
-  # * Show Picture
-  #     name       : file name
-  #     origin     : starting point
-  #     x          : x-coordinate
-  #     y          : y-coordinate
-  #     zoom_x     : x directional zoom rate
-  #     zoom_y     : y directional zoom rate
-  #     opacity    : opacity level
-  #     blend_type : blend method
-  #--------------------------------------------------------------------------
-  def show(name, origin, x, y, zoom_x, zoom_y, opacity, blend_type)
-    # Localization: check if this picture exists
-    # in the appropriate language folder, else
-    # default to the base graphics folder
-    translation_name = "#{$persistent.langcode}/#{name}"
-    if File.exists?("Graphics/Pictures/#{translation_name}.png")
-      @name = translation_name
-    else
-      @name = name
-    end
-    @origin = origin
-    @x = x.to_f
-    @y = y.to_f
-    @zoom_x = zoom_x.to_f
-    @zoom_y = zoom_y.to_f
-    @opacity = opacity.to_f
-    @blend_type = blend_type
-    @duration = 0
-    @target_x = @x
-    @target_y = @y
-    @target_zoom_x = @zoom_x
-    @target_zoom_y = @zoom_y
-    @target_opacity = @opacity
-    @tone = Tone.new(0, 0, 0, 0)
-    @tone_target = Tone.new(0, 0, 0, 0)
-    @tone_duration = 0
-    @angle = 0
-    @rotate_speed = 0
-  end
-  #--------------------------------------------------------------------------
-  # * Move Picture
-  #     duration   : time
-  #     origin     : starting point
-  #     x          : x-coordinate
-  #     y          : y-coordinate
-  #     zoom_x     : x directional zoom rate
-  #     zoom_y     : y directional zoom rate
-  #     opacity    : opacity level
-  #     blend_type : blend method
-  #--------------------------------------------------------------------------
-  def move(duration, origin, x, y, zoom_x, zoom_y, opacity, blend_type)
-    @duration = duration
-    @origin = origin
-    @target_x = x.to_f
-    @target_y = y.to_f
-    @target_zoom_x = zoom_x.to_f
-    @target_zoom_y = zoom_y.to_f
-    @target_opacity = opacity.to_f
-    @blend_type = blend_type
-  end
-  #--------------------------------------------------------------------------
-  # * Change Rotation Speed
-  #     speed : rotation speed
-  #--------------------------------------------------------------------------
-  def rotate(speed)
-    @rotate_speed = speed
-  end
-  #--------------------------------------------------------------------------
-  # * Start Change of Color Tone
-  #     tone     : color tone
-  #     duration : time
-  #--------------------------------------------------------------------------
-  def start_tone_change(tone, duration)
-    @tone_target = tone.clone
-    @tone_duration = duration
-    if @tone_duration == 0
-      @tone = @tone_target.clone
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Erase Picture
-  #--------------------------------------------------------------------------
-  def erase
-    @name = ""
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update
-  #--------------------------------------------------------------------------
-  def update
-    if @duration >= 1
-      d = @duration
-      @x = (@x * (d - 1) + @target_x) / d
-      @y = (@y * (d - 1) + @target_y) / d
-      @zoom_x = (@zoom_x * (d - 1) + @target_zoom_x) / d
-      @zoom_y = (@zoom_y * (d - 1) + @target_zoom_y) / d
-      @opacity = (@opacity * (d - 1) + @target_opacity) / d
-      @duration -= 1
-    end
-    if @tone_duration >= 1
-      d = @tone_duration
-      @tone.red = (@tone.red * (d - 1) + @tone_target.red) / d
-      @tone.green = (@tone.green * (d - 1) + @tone_target.green) / d
-      @tone.blue = (@tone.blue * (d - 1) + @tone_target.blue) / d
-      @tone.gray = (@tone.gray * (d - 1) + @tone_target.gray) / d
-      @tone_duration -= 1
-    end
-    if @rotate_speed != 0
-      @angle += @rotate_speed / 2.0
-      while @angle < 0
-        @angle += 360
-      end
-      @angle %= 360
-    end
-  end
-end