rmxp_extractor 1.8 → 1.9

data/Scripts/Game_Enemy.rb

@@ -1,317 +0,0 @@
-#==============================================================================
-# ** Game_Enemy
-#------------------------------------------------------------------------------
-#  This class handles enemies. It's used within the Game_Troop class
-#  ($game_troop).
-#==============================================================================
-
-class Game_Enemy < Game_Battler
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #     troop_id     : troop ID
-  #     member_index : troop member index
-  #--------------------------------------------------------------------------
-  def initialize(troop_id, member_index)
-    super()
-    @troop_id = troop_id
-    @member_index = member_index
-    troop = $data_troops[@troop_id]
-    @enemy_id = troop.members[@member_index].enemy_id
-    enemy = $data_enemies[@enemy_id]
-    @battler_name = enemy.battler_name
-    @battler_hue = enemy.battler_hue
-    @hp = maxhp
-    @sp = maxsp
-    @hidden = troop.members[@member_index].hidden
-    @immortal = troop.members[@member_index].immortal
-  end
-  #--------------------------------------------------------------------------
-  # * Get Enemy ID
-  #--------------------------------------------------------------------------
-  def id
-    return @enemy_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get Index
-  #--------------------------------------------------------------------------
-  def index
-    return @member_index
-  end
-  #--------------------------------------------------------------------------
-  # * Get Name
-  #--------------------------------------------------------------------------
-  def name
-    return $data_enemies[@enemy_id].name
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Maximum HP
-  #--------------------------------------------------------------------------
-  def base_maxhp
-    return $data_enemies[@enemy_id].maxhp
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Maximum SP
-  #--------------------------------------------------------------------------
-  def base_maxsp
-    return $data_enemies[@enemy_id].maxsp
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Strength
-  #--------------------------------------------------------------------------
-  def base_str
-    return $data_enemies[@enemy_id].str
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Dexterity
-  #--------------------------------------------------------------------------
-  def base_dex
-    return $data_enemies[@enemy_id].dex
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Agility
-  #--------------------------------------------------------------------------
-  def base_agi
-    return $data_enemies[@enemy_id].agi
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Intelligence
-  #--------------------------------------------------------------------------
-  def base_int
-    return $data_enemies[@enemy_id].int
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Attack Power
-  #--------------------------------------------------------------------------
-  def base_atk
-    return $data_enemies[@enemy_id].atk
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Physical Defense
-  #--------------------------------------------------------------------------
-  def base_pdef
-    return $data_enemies[@enemy_id].pdef
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Magic Defense
-  #--------------------------------------------------------------------------
-  def base_mdef
-    return $data_enemies[@enemy_id].mdef
-  end
-  #--------------------------------------------------------------------------
-  # * Get Basic Evasion
-  #--------------------------------------------------------------------------
-  def base_eva
-    return $data_enemies[@enemy_id].eva
-  end
-  #--------------------------------------------------------------------------
-  # * Get Offensive Animation ID for Normal Attack
-  #--------------------------------------------------------------------------
-  def animation1_id
-    return $data_enemies[@enemy_id].animation1_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get Target Animation ID for Normal Attack
-  #--------------------------------------------------------------------------
-  def animation2_id
-    return $data_enemies[@enemy_id].animation2_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get Element Revision Value
-  #     element_id : Element ID
-  #--------------------------------------------------------------------------
-  def element_rate(element_id)
-    # Get a numerical value corresponding to element effectiveness
-    table = [0,200,150,100,50,0,-100]
-    result = table[$data_enemies[@enemy_id].element_ranks[element_id]]
-    # If protected by state, this element is reduced by half
-    for i in @states
-      if $data_states[i].guard_element_set.include?(element_id)
-        result /= 2
-      end
-    end
-    # End Method
-    return result
-  end
-  #--------------------------------------------------------------------------
-  # * Get State Effectiveness
-  #--------------------------------------------------------------------------
-  def state_ranks
-    return $data_enemies[@enemy_id].state_ranks
-  end
-  #--------------------------------------------------------------------------
-  # * Determine State Guard
-  #     state_id : state ID
-  #--------------------------------------------------------------------------
-  def state_guard?(state_id)
-    return false
-  end
-  #--------------------------------------------------------------------------
-  # * Get Normal Attack Element
-  #--------------------------------------------------------------------------
-  def element_set
-    return []
-  end
-  #--------------------------------------------------------------------------
-  # * Get Normal Attack State Change (+)
-  #--------------------------------------------------------------------------
-  def plus_state_set
-    return []
-  end
-  #--------------------------------------------------------------------------
-  # * Get Normal Attack State Change (-)
-  #--------------------------------------------------------------------------
-  def minus_state_set
-    return []
-  end
-  #--------------------------------------------------------------------------
-  # * Aquire Actions
-  #--------------------------------------------------------------------------
-  def actions
-    return $data_enemies[@enemy_id].actions
-  end
-  #--------------------------------------------------------------------------
-  # * Get EXP
-  #--------------------------------------------------------------------------
-  def exp
-    return $data_enemies[@enemy_id].exp
-  end
-  #--------------------------------------------------------------------------
-  # * Get Gold
-  #--------------------------------------------------------------------------
-  def gold
-    return $data_enemies[@enemy_id].gold
-  end
-  #--------------------------------------------------------------------------
-  # * Get Item ID
-  #--------------------------------------------------------------------------
-  def item_id
-    return $data_enemies[@enemy_id].item_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get Weapon ID
-  #--------------------------------------------------------------------------
-  def weapon_id
-    return $data_enemies[@enemy_id].weapon_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get Armor ID
-  #--------------------------------------------------------------------------
-  def armor_id
-    return $data_enemies[@enemy_id].armor_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get Treasure Appearance Probability
-  #--------------------------------------------------------------------------
-  def treasure_prob
-    return $data_enemies[@enemy_id].treasure_prob
-  end
-  #--------------------------------------------------------------------------
-  # * Get Battle Screen X-Coordinate
-  #--------------------------------------------------------------------------
-  def screen_x
-    return $data_troops[@troop_id].members[@member_index].x
-  end
-  #--------------------------------------------------------------------------
-  # * Get Battle Screen Y-Coordinate
-  #--------------------------------------------------------------------------
-  def screen_y
-    return $data_troops[@troop_id].members[@member_index].y
-  end
-  #--------------------------------------------------------------------------
-  # * Get Battle Screen Z-Coordinate
-  #--------------------------------------------------------------------------
-  def screen_z
-    return screen_y
-  end
-  #--------------------------------------------------------------------------
-  # * Escape
-  #--------------------------------------------------------------------------
-  def escape
-    # Set hidden flag
-    @hidden = true
-    # Clear current action
-    self.current_action.clear
-  end
-  #--------------------------------------------------------------------------
-  # * Transform
-  #     enemy_id : ID of enemy to be transformed
-  #--------------------------------------------------------------------------
-  def transform(enemy_id)
-    # Change enemy ID
-    @enemy_id = enemy_id
-    # Change battler graphics
-    @battler_name = $data_enemies[@enemy_id].battler_name
-    @battler_hue = $data_enemies[@enemy_id].battler_hue
-    # Remake action
-    make_action
-  end
-  #--------------------------------------------------------------------------
-  # * Make Action
-  #--------------------------------------------------------------------------
-  def make_action
-    # Clear current action
-    self.current_action.clear
-    # If unable to move
-    unless self.movable?
-      # End Method
-      return
-    end
-    # Extract current effective actions
-    available_actions = []
-    rating_max = 0
-    for action in self.actions
-      # Confirm turn conditions
-      n = $game_temp.battle_turn
-      a = action.condition_turn_a
-      b = action.condition_turn_b
-      if (b == 0 and n != a) or
-         (b > 0 and (n < 1 or n < a or n % b != a % b))
-        next
-      end
-      # Confirm HP conditions
-      if self.hp * 100.0 / self.maxhp > action.condition_hp
-        next
-      end
-      # Confirm level conditions
-      if $game_party.max_level < action.condition_level
-        next
-      end
-      # Confirm switch conditions
-      switch_id = action.condition_switch_id
-      if switch_id > 0 and $game_switches[switch_id] == false
-        next
-      end
-      # Add this action to applicable conditions
-      available_actions.push(action)
-      if action.rating > rating_max
-        rating_max = action.rating
-      end
-    end
-    # Calculate total with max rating value at 3 (exclude 0 or less)
-    ratings_total = 0
-    for action in available_actions
-      if action.rating > rating_max - 3
-        ratings_total += action.rating - (rating_max - 3)
-      end
-    end
-    # If ratings total isn't 0
-    if ratings_total > 0
-      # Create random numbers
-      value = rand(ratings_total)
-      # Set things that correspond to created random numbers as current action
-      for action in available_actions
-        if action.rating > rating_max - 3
-          if value < action.rating - (rating_max - 3)
-            self.current_action.kind = action.kind
-            self.current_action.basic = action.basic
-            self.current_action.skill_id = action.skill_id
-            self.current_action.decide_random_target_for_enemy
-            return
-          else
-            value -= action.rating - (rating_max - 3)
-          end
-        end
-      end
-    end
-  end
-end

data/Scripts/Game_Event.rb

@@ -1,264 +0,0 @@
-#==============================================================================
-# ** Game_Event
-#------------------------------------------------------------------------------
-#  This class deals with events. It handles functions including event page
-#  switching via condition determinants, and running parallel process events.
-#  It's used within the Game_Map class.
-#==============================================================================
-
-class Game_Event < Game_Character
-  #--------------------------------------------------------------------------
-  # * Public Instance Variables
-  #--------------------------------------------------------------------------
-  attr_reader   :trigger                  # trigger
-  attr_reader   :list                     # list of event commands
-  attr_reader   :starting                 # starting flag
-  attr_reader   :collision                # collision array
-  attr_reader   :x
-  attr_reader   :y
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #     map_id : map ID
-  #     event  : event (RPG::Event)
-  #--------------------------------------------------------------------------
-  def initialize(map_id, event)
-    super()
-	@made_text = false
-    @map_id = map_id
-    @event = event
-    @id = @event.id
-    @erased = false
-    @starting = false
-    @through = true
-    @collision = [[0, 0]]
-    # Initialize custom flags
-    event.name.scan(/:([a-z]+)/) do |flag, *|
-      @custom_flags << flag.to_sym
-    end
-    # Add special event data if it exists
-    /!([a-z]+)/.match(event.name) do |name|
-      special = SpecialEventData.get(name.captures.first.to_sym)
-      @custom_flags.concat(special.flags)
-      @collision = special.collision
-    end
-    # Move to starting position
-    moveto(@event.x, @event.y)
-    refresh
-  end
-  #--------------------------------------------------------------------------
-  # * Return true if intersects with specified tile
-  #--------------------------------------------------------------------------
-  def intersects?(x, y)
-    @collision.each do |ox, oy|
-      return true if @x + ox == x && @y + oy == y
-    end
-    return false
-  end
-  #--------------------------------------------------------------------------
-  # * Return name
-  #--------------------------------------------------------------------------
-  def name
-    return @event.name
-  end
-  #--------------------------------------------------------------------------
-  # * Clear Starting Flag
-  #--------------------------------------------------------------------------
-  def clear_starting
-    @starting = false
-  end
-  #--------------------------------------------------------------------------
-  # * Determine if Over Trigger
-  #    (whether or not same position is starting condition)
-  #--------------------------------------------------------------------------
-  def over_trigger?
-    # If not through situation with character as graphic
-    if @character_name != "" and not @through
-      # Starting determinant is face
-      return false
-    end
-    # If this position on the map is impassable
-    unless $game_map.passable?(@x, @y, 0)
-      # Starting determinant is face
-      return false
-    end
-    # Starting determinant is same position
-    return true
-  end
-  #--------------------------------------------------------------------------
-  # * Start Event
-  #--------------------------------------------------------------------------
-  def start
-    # If list of event commands is not empty
-    if @list.size > 1
-      @starting = true
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Temporarily Erase
-  #--------------------------------------------------------------------------
-  def erase
-    @erased = true
-    refresh
-  end
-  #--------------------------------------------------------------------------
-  # * Refresh
-  #--------------------------------------------------------------------------
-  def refresh
-    # Initialize local variable: new_page
-    new_page = nil
-    # If not temporarily erased
-    unless @erased
-      # Check in order of large event pages
-      for page in @event.pages.reverse
-        # Make possible referrence for event condition with c
-        c = page.condition
-        # Switch 1 condition confirmation
-        if c.switch1_valid
-          if $game_switches[c.switch1_id] == false
-            next
-          end
-        end
-        # Switch 2 condition confirmation
-        if c.switch2_valid
-          if $game_switches[c.switch2_id] == false
-            next
-          end
-        end
-        # Variable condition confirmation
-        if c.variable_valid
-          if $game_variables[c.variable_id] < c.variable_value
-            next
-          end
-        end
-        # Self switch condition confirmation
-        if c.self_switch_valid
-          key = [@map_id, @event.id, c.self_switch_ch]
-          if $game_self_switches[key] != true
-            next
-          end
-        end
-        # Set local variable: new_page
-        new_page = page
-        # Remove loop
-        break
-      end
-    end
-    # If event page is the same as last time
-    if new_page == @page
-      # End method
-      return
-    end
-    # Set @page as current event page
-    @page = new_page
-    # Clear starting flag
-    clear_starting
-    # If no page fulfills conditions
-    if @page == nil
-      # Set each instance variable
-      @tile_id = 0
-      @character_name = ""
-      @character_hue = 0
-      @move_type = 0
-      @through = true
-      @trigger = nil
-      @list = nil
-      @interpreter = nil
-      # End method
-      return
-    end
-    # Set each instance variable
-    @tile_id = @page.graphic.tile_id
-    @character_name = @page.graphic.character_name
-    @character_hue = @page.graphic.character_hue
-    if @original_direction != @page.graphic.direction
-      @direction = @page.graphic.direction
-      @original_direction = @direction
-      @prelock_direction = 0
-    end
-    if @original_pattern != @page.graphic.pattern
-      @pattern = @page.graphic.pattern
-      @original_pattern = @pattern
-    end
-    @opacity = @page.graphic.opacity
-    @blend_type = @page.graphic.blend_type
-    @move_type = @page.move_type
-    @move_speed = @page.move_speed
-    @move_frequency = @page.move_frequency
-    @move_route = @page.move_route
-    @move_route_index = 0
-    @move_route_forcing = false
-    @walk_anime = @page.walk_anime
-    @step_anime = @page.step_anime
-    @direction_fix = @page.direction_fix
-    @through = @page.through
-    @always_on_top = @page.always_on_top
-    @trigger = @page.trigger
-    @list = @page.list
-    @interpreter = nil
-    # If trigger is [parallel process]
-    if @trigger == 4
-      # Create parallel process interpreter
-      @interpreter = Interpreter.new
-    end
-    # Auto event start determinant
-    check_event_trigger_auto
-  end
-  #--------------------------------------------------------------------------
-  # * Touch Event Starting Determinant
-  #--------------------------------------------------------------------------
-  def check_event_trigger_touch(x, y)
-    # If event is running
-    if $game_system.map_interpreter.running?
-      return
-    end
-    # If trigger is [touch from event] and consistent with player coordinates
-    if @trigger == 2 and x == $game_player.x and y == $game_player.y
-      # If starting determinant other than jumping is front event
-      if not jumping? and not over_trigger?
-        start
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Automatic Event Starting Determinant
-  #--------------------------------------------------------------------------
-  def check_event_trigger_auto
-    # If trigger is [touch from event] and consistent with player coordinates
-    if @trigger == 2 and @x == $game_player.x and @y == $game_player.y
-      # If starting determinant other than jumping is same position event
-      if not jumping? and over_trigger?
-        start
-      end
-    end
-    # If trigger is [auto run]
-    if @trigger == 3
-      start
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update
-  #--------------------------------------------------------------------------
-  def update
-    super
-
-	if(@made_text == false && @event.name.start_with?("@text"))
-	  if @list.size > 1 && @list[0].code == 101
-        $scene.new_maptext(Language.tr(@list[0].parameters[0].strip), @x, @y)
-		@list.delete_at(0)
-      end
-	  @made_text = true
-	end
-    # Automatic event starting determinant
-    check_event_trigger_auto
-    # If parallel process is valid
-    if @interpreter != nil
-      # If not running
-      unless @interpreter.running?
-        # Set up event
-        @interpreter.setup(@list, @event.id)
-      end
-      # Update interpreter
-      @interpreter.update
-    end
-  end
-end

data/Scripts/Game_FastTravel.rb

@@ -1,40 +0,0 @@
-class Game_FastTravel
-  attr_reader :zone
-  attr_accessor :enabled
-  alias :enabled? :enabled
-
-  class Map
-    attr_reader :id
-    attr_reader :x
-    attr_reader :y
-    attr_reader :dir
-
-    def initialize(id, x, y, dir)
-      @id = id
-      @x = x
-      @y = y
-      @dir = dir
-    end
-  end
-
-  def initialize
-    @unlocked = {}
-    @zone = nil
-    @enabled = false
-  end
-
-  def unlock(map, id, x, y, dir)
-    @unlocked[@zone][map] = Map.new(id, x, y, dir)
-  end
-
-  def zone=(zone)
-    @zone = zone
-    unless @unlocked.include? zone
-      @unlocked[zone] = {}
-    end
-  end
-
-  def unlocked_maps
-    @unlocked[@zone]
-  end
-end

data/Scripts/Game_Follower.rb

@@ -1,76 +0,0 @@
-#==============================================================================
-# ** Game_Follower
-#------------------------------------------------------------------------------
-#  This class handles player followers.
-#==============================================================================
-
-class Game_Follower < Game_Character
-  attr_accessor :leader
-
-  def initialize(leader, actor)
-    super()
-    @leader = leader
-    self.actor = actor
-    moveto(leader.x, leader.y)
-  end
-
-  # Overrides
-  def moveto(x, y)
-    @lox = x
-    @loy = y
-    super
-  end
-  def passable?(x, y, d)
-    return true
-  end
-  def check_event_trigger_here(triggers)
-    false
-  end
-  def check_event_trigger_there(triggers)
-    false
-  end
-  def check_event_trigger_touch(x, y)
-    false
-  end
-
-  # Change actor
-  def actor
-    @actor
-  end
-  def actor=(actor)
-    @actor = actor
-    if actor == nil
-      @character_name = ''
-      @character_hue = 0
-    else
-      # Set character file name and hue
-      @character_name = actor.character_name
-      @character_hue = actor.character_hue
-      # Initialize opacity level and blending method
-      @opacity = 255
-      @blend_type = 0
-    end
-  end
-
-  def update
-    @move_speed = $game_player.move_speed
-    unless moving?
-      if @lox != @leader.x || @loy != @leader.y
-        ox = @lox - @x
-        oy = @loy - @y
-        if ox < 0
-          move_left
-        elsif ox > 0
-          move_right
-        elsif oy < 0
-          move_up
-        elsif oy > 0
-          move_down
-        end
-        @lox = @leader.x
-        @loy = @leader.y
-      end
-    end
-    super
-  end
-end

data/Scripts/Game_Light.rb

@@ -1,13 +0,0 @@
-class Game_Light
-  attr_accessor :filename
-  attr_accessor :intensity
-  attr_accessor :x
-  attr_accessor :y
-
-  def initialize(filename, intensity, x, y)
-    @filename = filename
-    @intensity = intensity
-    @x = x
-    @y = y
-  end
-end