rmxp_extractor 1.8 → 2.0.0

data/Scripts/Game_Character 3.rb

@@ -1,505 +0,0 @@
-#==============================================================================
-# ** Game_Character (part 3)
-#------------------------------------------------------------------------------
-#  This class deals with characters. It's used as a superclass for the
-#  Game_Player and Game_Event classes.
-#==============================================================================
-
-class Game_Character
-  #--------------------------------------------------------------------------
-  # * Move Down
-  #     turn_enabled : a flag permits direction change on that spot
-  #--------------------------------------------------------------------------
-  def move_down(turn_enabled = true)
-    # Turn down
-    if turn_enabled
-      turn_down
-    end
-    # If passable
-    if passable?(@x, @y, 2)
-      # Turn down
-      turn_down
-      # Emit footprint
-      emit_footprint(2)
-      # Update coordinates
-      @y += 1
-      # Increase steps
-      increase_steps
-    # If impassable
-    else
-      # Determine if touch event is triggered
-      check_event_trigger_touch(@x, @y+1)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move Left
-  #     turn_enabled : a flag permits direction change on that spot
-  #--------------------------------------------------------------------------
-  def move_left(turn_enabled = true)
-    # Turn left
-    if turn_enabled
-      turn_left
-    end
-    # If passable
-    if passable?(@x, @y, 4)
-      # Turn left
-      turn_left
-      # Emit footprint
-      emit_footprint(4)
-      # Update coordinates
-      @x -= 1
-      # Increase steps
-      increase_steps
-    # If impassable
-    else
-      # Determine if touch event is triggered
-      check_event_trigger_touch(@x-1, @y)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move Right
-  #     turn_enabled : a flag permits direction change on that spot
-  #--------------------------------------------------------------------------
-  def move_right(turn_enabled = true)
-    # Turn right
-    if turn_enabled
-      turn_right
-    end
-    # If passable
-    if passable?(@x, @y, 6)
-      # Turn right
-      turn_right
-      # Emit footprint
-      emit_footprint(6)
-      # Update coordinates
-      @x += 1
-      # Increase steps
-      increase_steps
-    # If impassable
-    else
-      # Determine if touch event is triggered
-      check_event_trigger_touch(@x+1, @y)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move up
-  #     turn_enabled : a flag permits direction change on that spot
-  #--------------------------------------------------------------------------
-  def move_up(turn_enabled = true)
-    # Turn up
-    if turn_enabled
-      turn_up
-    end
-    # If passable
-    if passable?(@x, @y, 8)
-      # Turn up
-      turn_up
-      # Emit footprint
-      emit_footprint(8)
-      # Update coordinates
-      @y -= 1
-      # Increase steps
-      increase_steps
-    # If impassable
-    else
-      # Determine if touch event is triggered
-      check_event_trigger_touch(@x, @y-1)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move Lower Left
-  #--------------------------------------------------------------------------
-  def move_lower_left
-    # If no direction fix
-    unless @direction_fix
-      # Face down is facing right or up
-      @direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
-    end
-    # When a down to left or a left to down course is passable
-    if (passable?(@x, @y, 2) and passable?(@x, @y + 1, 4)) or
-       (passable?(@x, @y, 4) and passable?(@x - 1, @y, 2))
-      # Update coordinates
-      @x -= 1
-      @y += 1
-      # Increase steps
-      increase_steps
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move Lower Right
-  #--------------------------------------------------------------------------
-  def move_lower_right
-    # If no direction fix
-    unless @direction_fix
-      # Face right if facing left, and face down if facing up
-      @direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
-    end
-    # When a down to right or a right to down course is passable
-    if (passable?(@x, @y, 2) and passable?(@x, @y + 1, 6)) or
-       (passable?(@x, @y, 6) and passable?(@x + 1, @y, 2))
-      # Update coordinates
-      @x += 1
-      @y += 1
-      # Increase steps
-      increase_steps
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move Upper Left
-  #--------------------------------------------------------------------------
-  def move_upper_left
-    # If no direction fix
-    unless @direction_fix
-      # Face left if facing right, and face up if facing down
-      @direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
-    end
-    # When an up to left or a left to up course is passable
-    if (passable?(@x, @y, 8) and passable?(@x, @y - 1, 4)) or
-       (passable?(@x, @y, 4) and passable?(@x - 1, @y, 8))
-      # Update coordinates
-      @x -= 1
-      @y -= 1
-      # Increase steps
-      increase_steps
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move Upper Right
-  #--------------------------------------------------------------------------
-  def move_upper_right
-    # If no direction fix
-    unless @direction_fix
-      # Face right if facing left, and face up if facing down
-      @direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
-    end
-    # When an up to right or a right to up course is passable
-    if (passable?(@x, @y, 8) and passable?(@x, @y - 1, 6)) or
-       (passable?(@x, @y, 6) and passable?(@x + 1, @y, 8))
-      # Update coordinates
-      @x += 1
-      @y -= 1
-      # Increase steps
-      increase_steps
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move at Random
-  #--------------------------------------------------------------------------
-  def move_random
-    case rand(4)
-    when 0  # Move down
-      move_down(false)
-    when 1  # Move left
-      move_left(false)
-    when 2  # Move right
-      move_right(false)
-    when 3  # Move up
-      move_up(false)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move toward Player
-  #--------------------------------------------------------------------------
-  def move_toward_player
-    # Get difference in player coordinates
-    sx = @x - $game_player.x
-    sy = @y - $game_player.y
-    # If coordinates are equal
-    if sx == 0 and sy == 0
-      return
-    end
-    # Get absolute value of difference
-    abs_sx = sx.abs
-    abs_sy = sy.abs
-    # If horizontal and vertical distances are equal
-    if abs_sx == abs_sy
-      # Increase one of them randomly by 1
-      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
-    end
-    # If horizontal distance is longer
-    if abs_sx > abs_sy
-      # Move towards player, prioritize left and right directions
-      sx > 0 ? move_left : move_right
-      if not moving? and sy != 0
-        sy > 0 ? move_up : move_down
-      end
-    # If vertical distance is longer
-    else
-      # Move towards player, prioritize up and down directions
-      sy > 0 ? move_up : move_down
-      if not moving? and sx != 0
-        sx > 0 ? move_left : move_right
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Move away from Player
-  #--------------------------------------------------------------------------
-  def move_away_from_player
-    # Get difference in player coordinates
-    sx = @x - $game_player.x
-    sy = @y - $game_player.y
-    # If coordinates are equal
-    if sx == 0 and sy == 0
-      return
-    end
-    # Get absolute value of difference
-    abs_sx = sx.abs
-    abs_sy = sy.abs
-    # If horizontal and vertical distances are equal
-    if abs_sx == abs_sy
-      # Increase one of them randomly by 1
-      rand(2) == 0 ? abs_sx += 1 : abs_sy += 1
-    end
-    # If horizontal distance is longer
-    if abs_sx > abs_sy
-      # Move away from player, prioritize left and right directions
-      sx > 0 ? move_right : move_left
-      if not moving? and sy != 0
-        sy > 0 ? move_down : move_up
-      end
-    # If vertical distance is longer
-    else
-      # Move away from player, prioritize up and down directions
-      sy > 0 ? move_down : move_up
-      if not moving? and sx != 0
-        sx > 0 ? move_right : move_left
-      end
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * 1 Step Forward
-  #--------------------------------------------------------------------------
-  def move_forward
-    case @direction
-    when 2
-      move_down(false)
-    when 4
-      move_left(false)
-    when 6
-      move_right(false)
-    when 8
-      move_up(false)
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * 1 Step Backward
-  #--------------------------------------------------------------------------
-  def move_backward
-    # Remember direction fix situation
-    last_direction_fix = @direction_fix
-    # Force directino fix
-    @direction_fix = true
-    # Branch by direction
-    case @direction
-    when 2  # Down
-      move_up(false)
-    when 4  # Left
-      move_right(false)
-    when 6  # Right
-      move_left(false)
-    when 8  # Up
-      move_down(false)
-    end
-    # Return direction fix situation back to normal
-    @direction_fix = last_direction_fix
-  end
-  #--------------------------------------------------------------------------
-  # * Jump
-  #     x_plus : x-coordinate plus value
-  #     y_plus : y-coordinate plus value
-  #--------------------------------------------------------------------------
-  def jump(x_plus, y_plus)
-    # If plus value is not (0,0)
-    if x_plus != 0 or y_plus != 0
-      # If horizontal distnace is longer
-      if x_plus.abs > y_plus.abs
-        # Change direction to left or right
-        x_plus < 0 ? turn_left : turn_right
-      # If vertical distance is longer, or equal
-      else
-        # Change direction to up or down
-        y_plus < 0 ? turn_up : turn_down
-      end
-    end
-    # Calculate new coordinates
-    new_x = @x + x_plus
-    new_y = @y + y_plus
-    # If plus value is (0,0) or jump destination is passable
-    if (x_plus == 0 and y_plus == 0) or passable?(new_x, new_y, 0)
-      # Straighten position
-      straighten
-      # Update coordinates
-      @x = new_x
-      @y = new_y
-      # Calculate distance
-      distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
-      # Set jump count
-      @jump_peak = 10 + distance - @move_speed
-      @jump_count = @jump_peak * 2
-      # Clear stop count
-      @stop_count = 0
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn Down
-  #--------------------------------------------------------------------------
-  def turn_down
-    unless @direction_fix
-      @direction = 2
-      @stop_count = 0
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn Left
-  #--------------------------------------------------------------------------
-  def turn_left
-    unless @direction_fix
-      @direction = 4
-      @stop_count = 0
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn Right
-  #--------------------------------------------------------------------------
-  def turn_right
-    unless @direction_fix
-      @direction = 6
-      @stop_count = 0
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn Up
-  #--------------------------------------------------------------------------
-  def turn_up
-    unless @direction_fix
-      @direction = 8
-      @stop_count = 0
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn 90° Right
-  #--------------------------------------------------------------------------
-  def turn_right_90
-    case @direction
-    when 2
-      turn_left
-    when 4
-      turn_up
-    when 6
-      turn_down
-    when 8
-      turn_right
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn 90° Left
-  #--------------------------------------------------------------------------
-  def turn_left_90
-    case @direction
-    when 2
-      turn_right
-    when 4
-      turn_down
-    when 6
-      turn_up
-    when 8
-      turn_left
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn 180°
-  #--------------------------------------------------------------------------
-  def turn_180
-    case @direction
-    when 2
-      turn_up
-    when 4
-      turn_right
-    when 6
-      turn_left
-    when 8
-      turn_down
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn 90° Right or Left
-  #--------------------------------------------------------------------------
-  def turn_right_or_left_90
-    if rand(2) == 0
-      turn_right_90
-    else
-      turn_left_90
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn at Random
-  #--------------------------------------------------------------------------
-  def turn_random
-    case rand(4)
-    when 0
-      turn_up
-    when 1
-      turn_right
-    when 2
-      turn_left
-    when 3
-      turn_down
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn Towards Player
-  #--------------------------------------------------------------------------
-  def turn_toward_player
-    # Get difference in player coordinates
-    sx = @x - $game_player.x
-    sy = @y - $game_player.y
-    # If coordinates are equal
-    if sx == 0 and sy == 0
-      return
-    end
-    # If horizontal distance is longer
-    if sx.abs > sy.abs
-      # Turn to the right or left towards player
-      sx > 0 ? turn_left : turn_right
-    # If vertical distance is longer
-    else
-      # Turn up or down towards player
-      sy > 0 ? turn_up : turn_down
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Turn Away from Player
-  #--------------------------------------------------------------------------
-  def turn_away_from_player
-    # Get difference in player coordinates
-    sx = @x - $game_player.x
-    sy = @y - $game_player.y
-    # If coordinates are equal
-    if sx == 0 and sy == 0
-      return
-    end
-    # If horizontal distance is longer
-    if sx.abs > sy.abs
-      # Turn to the right or left away from player
-      sx > 0 ? turn_right : turn_left
-    # If vertical distance is longer
-    else
-      # Turn up or down away from player
-      sy > 0 ? turn_down : turn_up
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Emit Footprint
-  #--------------------------------------------------------------------------
-  def emit_footprint(direction)
-    if $game_map.counter?(@x, @y) && !$game_switches[101] && !$game_switches[111]
-      $scene.new_footprint(direction, @x, @y)
-    end
-  end
-  def emit_footsplash(direction)
-    if $game_map.counter?(@x, @y) && $game_switches[101] && !$game_switches[111]
-      $scene.new_footsplash(direction, @x, @y)
-    end
-  end
-end

data/Scripts/Game_CommonEvent.rb

@@ -1,70 +0,0 @@
-#==============================================================================
-# ** Game_CommonEvent
-#------------------------------------------------------------------------------
-#  This class handles common events. It includes execution of parallel process
-#  event. This class is used within the Game_Map class ($game_map).
-#==============================================================================
-
-class Game_CommonEvent
-  #--------------------------------------------------------------------------
-  # * Object Initialization
-  #     common_event_id : common event ID
-  #--------------------------------------------------------------------------
-  def initialize(common_event_id)
-    @common_event_id = common_event_id
-    @interpreter = nil
-    refresh
-  end
-  #--------------------------------------------------------------------------
-  # * Get Name
-  #--------------------------------------------------------------------------
-  def name
-    return $data_common_events[@common_event_id].name
-  end
-  #--------------------------------------------------------------------------
-  # * Get Trigger
-  #--------------------------------------------------------------------------
-  def trigger
-    return $data_common_events[@common_event_id].trigger
-  end
-  #--------------------------------------------------------------------------
-  # * Get Condition Switch ID
-  #--------------------------------------------------------------------------
-  def switch_id
-    return $data_common_events[@common_event_id].switch_id
-  end
-  #--------------------------------------------------------------------------
-  # * Get List of Event Commands
-  #--------------------------------------------------------------------------
-  def list
-    return $data_common_events[@common_event_id].list
-  end
-  #--------------------------------------------------------------------------
-  # * Refresh
-  #--------------------------------------------------------------------------
-  def refresh
-    # Create an interpreter for parallel process if necessary
-    if self.trigger == 2 and $game_switches[self.switch_id] == true
-      if @interpreter == nil
-        @interpreter = Interpreter.new
-      end
-    else
-      @interpreter = nil
-    end
-  end
-  #--------------------------------------------------------------------------
-  # * Frame Update
-  #--------------------------------------------------------------------------
-  def update
-    # If parallel process is valid
-    if @interpreter != nil
-      # If not running
-      unless @interpreter.running?
-        # Set up event
-        @interpreter.setup(self.list, 0)
-      end
-      # Update interpreter
-      @interpreter.update
-    end
-  end
-end