rmxp_extractor 1.5 → 1.6

data/Scripts/Game_Enemy.rb

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

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

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

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

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