rgss3_default_scripts 1.0.2

data/lib/rgss3_default_scripts/Game_Character.rb

@@ -0,0 +1,396 @@
+#==============================================================================
+# ** Game_Character
+#------------------------------------------------------------------------------
+#  A character class with mainly movement route and other such processing
+# added. It is used as a super class of Game_Player, Game_Follower,
+# GameVehicle, and Game_Event.
+#==============================================================================
+
+class Game_Character < Game_CharacterBase
+  #--------------------------------------------------------------------------
+  # * Constants
+  #--------------------------------------------------------------------------
+  ROUTE_END               = 0             # End of Move Route
+  ROUTE_MOVE_DOWN         = 1             # Move Down
+  ROUTE_MOVE_LEFT         = 2             # Move Left
+  ROUTE_MOVE_RIGHT        = 3             # Move Right
+  ROUTE_MOVE_UP           = 4             # Move Up
+  ROUTE_MOVE_LOWER_L      = 5             # Move Lower Left
+  ROUTE_MOVE_LOWER_R      = 6             # Move Lower Right
+  ROUTE_MOVE_UPPER_L      = 7             # Move Upper Left
+  ROUTE_MOVE_UPPER_R      = 8             # Move Upper Right
+  ROUTE_MOVE_RANDOM       = 9             # Move at Random
+  ROUTE_MOVE_TOWARD       = 10            # Move toward Player
+  ROUTE_MOVE_AWAY         = 11            # Move away from Player
+  ROUTE_MOVE_FORWARD      = 12            # 1 Step Forward
+  ROUTE_MOVE_BACKWARD     = 13            # 1 Step Backward
+  ROUTE_JUMP              = 14            # Jump
+  ROUTE_WAIT              = 15            # Wait
+  ROUTE_TURN_DOWN         = 16            # Turn Down
+  ROUTE_TURN_LEFT         = 17            # Turn Left
+  ROUTE_TURN_RIGHT        = 18            # Turn Right
+  ROUTE_TURN_UP           = 19            # Turn Up
+  ROUTE_TURN_90D_R        = 20            # Turn 90 Degrees Right
+  ROUTE_TURN_90D_L        = 21            # Turn 90 Degrees Left
+  ROUTE_TURN_180D         = 22            # Turn 180 Degrees
+  ROUTE_TURN_90D_R_L      = 23            # Turn 90 Degrees Right/Left
+  ROUTE_TURN_RANDOM       = 24            # Turn at Random
+  ROUTE_TURN_TOWARD       = 25            # Turn toward player
+  ROUTE_TURN_AWAY         = 26            # Turn away from Player
+  ROUTE_SWITCH_ON         = 27            # Switch ON
+  ROUTE_SWITCH_OFF        = 28            # Switch OFF
+  ROUTE_CHANGE_SPEED      = 29            # Change Speed
+  ROUTE_CHANGE_FREQ       = 30            # Change Frequency
+  ROUTE_WALK_ANIME_ON     = 31            # Walking Animation ON
+  ROUTE_WALK_ANIME_OFF    = 32            # Walking Animation OFF
+  ROUTE_STEP_ANIME_ON     = 33            # Stepping Animation ON
+  ROUTE_STEP_ANIME_OFF    = 34            # Stepping Animation OFF
+  ROUTE_DIR_FIX_ON        = 35            # Direction Fix ON
+  ROUTE_DIR_FIX_OFF       = 36            # Direction Fix OFF
+  ROUTE_THROUGH_ON        = 37            # Pass-Through ON
+  ROUTE_THROUGH_OFF       = 38            # Pass-Through OFF
+  ROUTE_TRANSPARENT_ON    = 39            # Transparent ON
+  ROUTE_TRANSPARENT_OFF   = 40            # Transparent OFF
+  ROUTE_CHANGE_GRAPHIC    = 41            # Change Graphic
+  ROUTE_CHANGE_OPACITY    = 42            # Change Opacity
+  ROUTE_CHANGE_BLENDING   = 43            # Change Blending
+  ROUTE_PLAY_SE           = 44            # Play SE
+  ROUTE_SCRIPT            = 45            # Script
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_reader   :move_route_forcing       # forced move route flag
+  #--------------------------------------------------------------------------
+  # * Initialize Public Member Variables
+  #--------------------------------------------------------------------------
+  def init_public_members
+    super
+    @move_route_forcing = false
+  end
+  #--------------------------------------------------------------------------
+  # * Initialize Private Member Variables
+  #--------------------------------------------------------------------------
+  def init_private_members
+    super
+    @move_route = nil                 # Move route
+    @move_route_index = 0             # Move route execution position
+    @original_move_route = nil        # Original move route
+    @original_move_route_index = 0    # Original move route execution position
+    @wait_count = 0                   # Wait count
+  end
+  #--------------------------------------------------------------------------
+  # * Memorize Move Route
+  #--------------------------------------------------------------------------
+  def memorize_move_route
+    @original_move_route        = @move_route
+    @original_move_route_index  = @move_route_index
+  end
+  #--------------------------------------------------------------------------
+  # * Restore Move Route
+  #--------------------------------------------------------------------------
+  def restore_move_route
+    @move_route           = @original_move_route
+    @move_route_index     = @original_move_route_index
+    @original_move_route  = nil
+  end
+  #--------------------------------------------------------------------------
+  # * Force Move Route
+  #--------------------------------------------------------------------------
+  def force_move_route(move_route)
+    memorize_move_route unless @original_move_route
+    @move_route = move_route
+    @move_route_index = 0
+    @move_route_forcing = true
+    @prelock_direction = 0
+    @wait_count = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Update While Stopped
+  #--------------------------------------------------------------------------
+  def update_stop
+    super
+    update_routine_move if @move_route_forcing
+  end
+  #--------------------------------------------------------------------------
+  # * Update Move Along Route
+  #--------------------------------------------------------------------------
+  def update_routine_move
+    if @wait_count > 0
+      @wait_count -= 1
+    else
+      @move_succeed = true
+      command = @move_route.list[@move_route_index]
+      if command
+        process_move_command(command)
+        advance_move_route_index
+      end
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Process Move Command
+  #--------------------------------------------------------------------------
+  def process_move_command(command)
+    params = command.parameters
+    case command.code
+    when ROUTE_END;               process_route_end
+    when ROUTE_MOVE_DOWN;         move_straight(2)
+    when ROUTE_MOVE_LEFT;         move_straight(4)
+    when ROUTE_MOVE_RIGHT;        move_straight(6)
+    when ROUTE_MOVE_UP;           move_straight(8)
+    when ROUTE_MOVE_LOWER_L;      move_diagonal(4, 2)
+    when ROUTE_MOVE_LOWER_R;      move_diagonal(6, 2)
+    when ROUTE_MOVE_UPPER_L;      move_diagonal(4, 8)
+    when ROUTE_MOVE_UPPER_R;      move_diagonal(6, 8)
+    when ROUTE_MOVE_RANDOM;       move_random
+    when ROUTE_MOVE_TOWARD;       move_toward_player
+    when ROUTE_MOVE_AWAY;         move_away_from_player
+    when ROUTE_MOVE_FORWARD;      move_forward
+    when ROUTE_MOVE_BACKWARD;     move_backward
+    when ROUTE_JUMP;              jump(params[0], params[1])
+    when ROUTE_WAIT;              @wait_count = params[0] - 1
+    when ROUTE_TURN_DOWN;         set_direction(2)
+    when ROUTE_TURN_LEFT;         set_direction(4)
+    when ROUTE_TURN_RIGHT;        set_direction(6)
+    when ROUTE_TURN_UP;           set_direction(8)
+    when ROUTE_TURN_90D_R;        turn_right_90
+    when ROUTE_TURN_90D_L;        turn_left_90
+    when ROUTE_TURN_180D;         turn_180
+    when ROUTE_TURN_90D_R_L;      turn_right_or_left_90
+    when ROUTE_TURN_RANDOM;       turn_random
+    when ROUTE_TURN_TOWARD;       turn_toward_player
+    when ROUTE_TURN_AWAY;         turn_away_from_player
+    when ROUTE_SWITCH_ON;         $game_switches[params[0]] = true
+    when ROUTE_SWITCH_OFF;        $game_switches[params[0]] = false
+    when ROUTE_CHANGE_SPEED;      @move_speed = params[0]
+    when ROUTE_CHANGE_FREQ;       @move_frequency = params[0]
+    when ROUTE_WALK_ANIME_ON;     @walk_anime = true
+    when ROUTE_WALK_ANIME_OFF;    @walk_anime = false
+    when ROUTE_STEP_ANIME_ON;     @step_anime = true
+    when ROUTE_STEP_ANIME_OFF;    @step_anime = false
+    when ROUTE_DIR_FIX_ON;        @direction_fix = true
+    when ROUTE_DIR_FIX_OFF;       @direction_fix = false
+    when ROUTE_THROUGH_ON;        @through = true
+    when ROUTE_THROUGH_OFF;       @through = false
+    when ROUTE_TRANSPARENT_ON;    @transparent = true
+    when ROUTE_TRANSPARENT_OFF;   @transparent = false
+    when ROUTE_CHANGE_GRAPHIC;    set_graphic(params[0], params[1])
+    when ROUTE_CHANGE_OPACITY;    @opacity = params[0]
+    when ROUTE_CHANGE_BLENDING;   @blend_type = params[0]
+    when ROUTE_PLAY_SE;           params[0].play
+    when ROUTE_SCRIPT;            eval(params[0])
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Distance in X Axis Direction
+  #--------------------------------------------------------------------------
+  def distance_x_from(x)
+    result = @x - x
+    if $game_map.loop_horizontal? && result.abs > $game_map.width / 2
+      if result < 0
+        result += $game_map.width
+      else
+        result -= $game_map.width
+      end
+    end
+    result
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Distance in Y Axis Direction
+  #--------------------------------------------------------------------------
+  def distance_y_from(y)
+    result = @y - y
+    if $game_map.loop_vertical? && result.abs > $game_map.height / 2
+      if result < 0
+        result += $game_map.height
+      else
+        result -= $game_map.height
+      end
+    end
+    result
+  end
+  #--------------------------------------------------------------------------
+  # * Move at Random
+  #--------------------------------------------------------------------------
+  def move_random
+    move_straight(2 + rand(4) * 2, false)
+  end
+  #--------------------------------------------------------------------------
+  # * Move Toward Character
+  #--------------------------------------------------------------------------
+  def move_toward_character(character)
+    sx = distance_x_from(character.x)
+    sy = distance_y_from(character.y)
+    if sx.abs > sy.abs
+      move_straight(sx > 0 ? 4 : 6)
+      move_straight(sy > 0 ? 8 : 2) if !@move_succeed && sy != 0
+    elsif sy != 0
+      move_straight(sy > 0 ? 8 : 2)
+      move_straight(sx > 0 ? 4 : 6) if !@move_succeed && sx != 0
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Move Away from Character
+  #--------------------------------------------------------------------------
+  def move_away_from_character(character)
+    sx = distance_x_from(character.x)
+    sy = distance_y_from(character.y)
+    if sx.abs > sy.abs
+      move_straight(sx > 0 ? 6 : 4)
+      move_straight(sy > 0 ? 2 : 8) if !@move_succeed && sy != 0
+    elsif sy != 0
+      move_straight(sy > 0 ? 2 : 8)
+      move_straight(sx > 0 ? 6 : 4) if !@move_succeed && sx != 0
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Turn Toward Character
+  #--------------------------------------------------------------------------
+  def turn_toward_character(character)
+    sx = distance_x_from(character.x)
+    sy = distance_y_from(character.y)
+    if sx.abs > sy.abs
+      set_direction(sx > 0 ? 4 : 6)
+    elsif sy != 0
+      set_direction(sy > 0 ? 8 : 2)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Turn Away from Character
+  #--------------------------------------------------------------------------
+  def turn_away_from_character(character)
+    sx = distance_x_from(character.x)
+    sy = distance_y_from(character.y)
+    if sx.abs > sy.abs
+      set_direction(sx > 0 ? 6 : 4)
+    elsif sy != 0
+      set_direction(sy > 0 ? 2 : 8)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Turn toward Player
+  #--------------------------------------------------------------------------
+  def turn_toward_player
+    turn_toward_character($game_player)
+  end
+  #--------------------------------------------------------------------------
+  # * Turn away from Player
+  #--------------------------------------------------------------------------
+  def turn_away_from_player
+    turn_away_from_character($game_player)
+  end
+  #--------------------------------------------------------------------------
+  # * Move toward Player
+  #--------------------------------------------------------------------------
+  def move_toward_player
+    move_toward_character($game_player)
+  end
+  #--------------------------------------------------------------------------
+  # * Move away from Player
+  #--------------------------------------------------------------------------
+  def move_away_from_player
+    move_away_from_character($game_player)
+  end
+  #--------------------------------------------------------------------------
+  # * 1 Step Forward
+  #--------------------------------------------------------------------------
+  def move_forward
+    move_straight(@direction)
+  end
+  #--------------------------------------------------------------------------
+  # * 1 Step Backward
+  #--------------------------------------------------------------------------
+  def move_backward
+    last_direction_fix = @direction_fix
+    @direction_fix = true
+    move_straight(reverse_dir(@direction), false)
+    @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 x_plus.abs > y_plus.abs
+      set_direction(x_plus < 0 ? 4 : 6) if x_plus != 0
+    else
+      set_direction(y_plus < 0 ? 8 : 2) if y_plus != 0
+    end
+    @x += x_plus
+    @y += y_plus
+    distance = Math.sqrt(x_plus * x_plus + y_plus * y_plus).round
+    @jump_peak = 10 + distance - @move_speed
+    @jump_count = @jump_peak * 2
+    @stop_count = 0
+    straighten
+  end
+  #--------------------------------------------------------------------------
+  # * Process Move Route End
+  #--------------------------------------------------------------------------
+  def process_route_end
+    if @move_route.repeat
+      @move_route_index = -1
+    elsif @move_route_forcing
+      @move_route_forcing = false
+      restore_move_route
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Advance Execution Position of Move Route
+  #--------------------------------------------------------------------------
+  def advance_move_route_index
+    @move_route_index += 1 if @move_succeed || @move_route.skippable
+  end
+  #--------------------------------------------------------------------------
+  # * Turn 90° Right
+  #--------------------------------------------------------------------------
+  def turn_right_90
+    case @direction
+    when 2;  set_direction(4)
+    when 4;  set_direction(8)
+    when 6;  set_direction(2)
+    when 8;  set_direction(6)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Turn 90° Left
+  #--------------------------------------------------------------------------
+  def turn_left_90
+    case @direction
+    when 2;  set_direction(6)
+    when 4;  set_direction(2)
+    when 6;  set_direction(8)
+    when 8;  set_direction(4)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Turn 180°
+  #--------------------------------------------------------------------------
+  def turn_180
+    set_direction(reverse_dir(@direction))
+  end
+  #--------------------------------------------------------------------------
+  # * Turn 90° Right or Left
+  #--------------------------------------------------------------------------
+  def turn_right_or_left_90
+    case rand(2)
+    when 0;  turn_right_90
+    when 1;  turn_left_90
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Turn at Random
+  #--------------------------------------------------------------------------
+  def turn_random
+    set_direction(2 + rand(4) * 2)
+  end
+  #--------------------------------------------------------------------------
+  # * Swap Character Positions
+  #--------------------------------------------------------------------------
+  def swap(character)
+    new_x = character.x
+    new_y = character.y
+    character.moveto(x, y)
+    moveto(new_x, new_y)
+  end
+end

data/lib/rgss3_default_scripts/Game_CharacterBase.rb

@@ -0,0 +1,443 @@
+#==============================================================================
+# ** Game_CharacterBase
+#------------------------------------------------------------------------------
+#  This base class handles characters. It retains basic information, such as 
+# coordinates and graphics, shared by all characters.
+#==============================================================================
+
+class Game_CharacterBase
+  #--------------------------------------------------------------------------
+  # * Public Instance Variables
+  #--------------------------------------------------------------------------
+  attr_reader   :id                       # ID
+  attr_reader   :x                        # map X coordinate (logical)
+  attr_reader   :y                        # map Y coordinate (logical)
+  attr_reader   :real_x                   # map X coordinate (real)
+  attr_reader   :real_y                   # map Y coordinate (real)
+  attr_reader   :tile_id                  # tile ID (invalid if 0)
+  attr_reader   :character_name           # character graphic filename
+  attr_reader   :character_index          # character graphic index
+  attr_reader   :move_speed               # movement speed
+  attr_reader   :move_frequency           # movement frequency
+  attr_reader   :walk_anime               # walking animation
+  attr_reader   :step_anime               # stepping animation
+  attr_reader   :direction_fix            # direction fix
+  attr_reader   :opacity                  # opacity level
+  attr_reader   :blend_type               # blending method
+  attr_reader   :direction                # direction
+  attr_reader   :pattern                  # pattern
+  attr_reader   :priority_type            # priority type
+  attr_reader   :through                  # pass-through
+  attr_reader   :bush_depth               # bush depth
+  attr_accessor :animation_id             # animation ID
+  attr_accessor :balloon_id               # balloon icon ID
+  attr_accessor :transparent              # transparency flag
+  #--------------------------------------------------------------------------
+  # * Object Initialization
+  #--------------------------------------------------------------------------
+  def initialize
+    init_public_members
+    init_private_members
+  end
+  #--------------------------------------------------------------------------
+  # * Initialize Public Member Variables
+  #--------------------------------------------------------------------------
+  def init_public_members
+    @id = 0
+    @x = 0
+    @y = 0
+    @real_x = 0
+    @real_y = 0
+    @tile_id = 0
+    @character_name = ""
+    @character_index = 0
+    @move_speed = 4
+    @move_frequency = 6
+    @walk_anime = true
+    @step_anime = false
+    @direction_fix = false
+    @opacity = 255
+    @blend_type = 0
+    @direction = 2
+    @pattern = 1
+    @priority_type = 1
+    @through = false
+    @bush_depth = 0
+    @animation_id = 0
+    @balloon_id = 0
+    @transparent = false
+  end
+  #--------------------------------------------------------------------------
+  # * Initialize Private Member Variables
+  #--------------------------------------------------------------------------
+  def init_private_members
+    @original_direction = 2               # Original direction
+    @original_pattern = 1                 # Original pattern
+    @anime_count = 0                      # Animation count
+    @stop_count = 0                       # Stop count
+    @jump_count = 0                       # Jump count
+    @jump_peak = 0                        # Jump peak count
+    @locked = false                       # Locked flag
+    @prelock_direction = 0                # Direction before lock
+    @move_succeed = true                  # Move success flag
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Coordinate Match
+  #--------------------------------------------------------------------------
+  def pos?(x, y)
+    @x == x && @y == y
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Coordinates Match and Pass-Through Is Off (nt = No Through)
+  #--------------------------------------------------------------------------
+  def pos_nt?(x, y)
+    pos?(x, y) && !@through
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if [Same as Characters] Priority
+  #--------------------------------------------------------------------------
+  def normal_priority?
+    @priority_type == 1
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Moving
+  #--------------------------------------------------------------------------
+  def moving?
+    @real_x != @x || @real_y != @y
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Jumping
+  #--------------------------------------------------------------------------
+  def jumping?
+    @jump_count > 0
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Jump Height
+  #--------------------------------------------------------------------------
+  def jump_height
+    (@jump_peak * @jump_peak - (@jump_count - @jump_peak).abs ** 2) / 2
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Stopping
+  #--------------------------------------------------------------------------
+  def stopping?
+    !moving? && !jumping?
+  end
+  #--------------------------------------------------------------------------
+  # * Get Move Speed (Account for Dash)
+  #--------------------------------------------------------------------------
+  def real_move_speed
+    @move_speed + (dash? ? 1 : 0)
+  end
+  #--------------------------------------------------------------------------
+  # * Calculate Move Distance per Frame
+  #--------------------------------------------------------------------------
+  def distance_per_frame
+    2 ** real_move_speed / 256.0
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Dashing
+  #--------------------------------------------------------------------------
+  def dash?
+    return false
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Debug Pass-Through State
+  #--------------------------------------------------------------------------
+  def debug_through?
+    return false
+  end
+  #--------------------------------------------------------------------------
+  # * Straighten Position
+  #--------------------------------------------------------------------------
+  def straighten
+    @pattern = 1 if @walk_anime || @step_anime
+    @anime_count = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Get Opposite Direction
+  #     d : Direction (2,4,6,8)
+  #--------------------------------------------------------------------------
+  def reverse_dir(d)
+    return 10 - d
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Passable
+  #     d : Direction (2,4,6,8)
+  #--------------------------------------------------------------------------
+  def passable?(x, y, d)
+    x2 = $game_map.round_x_with_direction(x, d)
+    y2 = $game_map.round_y_with_direction(y, d)
+    return false unless $game_map.valid?(x2, y2)
+    return true if @through || debug_through?
+    return false unless map_passable?(x, y, d)
+    return false unless map_passable?(x2, y2, reverse_dir(d))
+    return false if collide_with_characters?(x2, y2)
+    return true
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Diagonal Passability
+  #     horz : Horizontal (4 or 6)
+  #     vert : Vertical (2 or 8)
+  #--------------------------------------------------------------------------
+  def diagonal_passable?(x, y, horz, vert)
+    x2 = $game_map.round_x_with_direction(x, horz)
+    y2 = $game_map.round_y_with_direction(y, vert)
+    (passable?(x, y, vert) && passable?(x, y2, horz)) ||
+    (passable?(x, y, horz) && passable?(x2, y, vert))
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Map is Passable
+  #     d : Direction (2,4,6,8)
+  #--------------------------------------------------------------------------
+  def map_passable?(x, y, d)
+    $game_map.passable?(x, y, d)
+  end
+  #--------------------------------------------------------------------------
+  # * Detect Collision with Character 
+  #--------------------------------------------------------------------------
+  def collide_with_characters?(x, y)
+    collide_with_events?(x, y) || collide_with_vehicles?(x, y)
+  end
+  #--------------------------------------------------------------------------
+  # * Detect Collision with Event
+  #--------------------------------------------------------------------------
+  def collide_with_events?(x, y)
+    $game_map.events_xy_nt(x, y).any? do |event|
+      event.normal_priority? || self.is_a?(Game_Event)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Detect Collision with Vehicle
+  #--------------------------------------------------------------------------
+  def collide_with_vehicles?(x, y)
+    $game_map.boat.pos_nt?(x, y) || $game_map.ship.pos_nt?(x, y)
+  end
+  #--------------------------------------------------------------------------
+  # * Move to Designated Position
+  #--------------------------------------------------------------------------
+  def moveto(x, y)
+    @x = x % $game_map.width
+    @y = y % $game_map.height
+    @real_x = @x
+    @real_y = @y
+    @prelock_direction = 0
+    straighten
+    update_bush_depth
+  end
+  #--------------------------------------------------------------------------
+  # * Change Direction to Designated Direction
+  #     d : Direction (2,4,6,8)
+  #--------------------------------------------------------------------------
+  def set_direction(d)
+    @direction = d if !@direction_fix && d != 0
+    @stop_count = 0
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Tile
+  #--------------------------------------------------------------------------
+  def tile?
+    @tile_id > 0 && @priority_type == 0
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Object Character
+  #--------------------------------------------------------------------------
+  def object_character?
+    @tile_id > 0 || @character_name[0, 1] == '!'
+  end
+  #--------------------------------------------------------------------------
+  # * Get Number of Pixels to Shift Up from Tile Position
+  #--------------------------------------------------------------------------
+  def shift_y
+    object_character? ? 0 : 4
+  end
+  #--------------------------------------------------------------------------
+  # * Get Screen X-Coordinates
+  #--------------------------------------------------------------------------
+  def screen_x
+    $game_map.adjust_x(@real_x) * 32 + 16
+  end
+  #--------------------------------------------------------------------------
+  # * Get Screen Y-Coordinates
+  #--------------------------------------------------------------------------
+  def screen_y
+    $game_map.adjust_y(@real_y) * 32 + 32 - shift_y - jump_height
+  end
+  #--------------------------------------------------------------------------
+  # * Get Screen Z-Coordinates
+  #--------------------------------------------------------------------------
+  def screen_z
+    @priority_type * 100
+  end
+  #--------------------------------------------------------------------------
+  # * Frame Update
+  #--------------------------------------------------------------------------
+  def update
+    update_animation
+    return update_jump if jumping?
+    return update_move if moving?
+    return update_stop
+  end
+  #--------------------------------------------------------------------------
+  # * Update While Jumping
+  #--------------------------------------------------------------------------
+  def update_jump
+    @jump_count -= 1
+    @real_x = (@real_x * @jump_count + @x) / (@jump_count + 1.0)
+    @real_y = (@real_y * @jump_count + @y) / (@jump_count + 1.0)
+    update_bush_depth
+    if @jump_count == 0
+      @real_x = @x = $game_map.round_x(@x)
+      @real_y = @y = $game_map.round_y(@y)
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Update While Moving
+  #--------------------------------------------------------------------------
+  def update_move
+    @real_x = [@real_x - distance_per_frame, @x].max if @x < @real_x
+    @real_x = [@real_x + distance_per_frame, @x].min if @x > @real_x
+    @real_y = [@real_y - distance_per_frame, @y].max if @y < @real_y
+    @real_y = [@real_y + distance_per_frame, @y].min if @y > @real_y
+    update_bush_depth unless moving?
+  end
+  #--------------------------------------------------------------------------
+  # * Update While Stopped
+  #--------------------------------------------------------------------------
+  def update_stop
+    @stop_count += 1 unless @locked
+  end
+  #--------------------------------------------------------------------------
+  # * Update Walking/Stepping Animation
+  #--------------------------------------------------------------------------
+  def update_animation
+    update_anime_count
+    if @anime_count > 18 - real_move_speed * 2
+      update_anime_pattern
+      @anime_count = 0
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Update Animation Count
+  #--------------------------------------------------------------------------
+  def update_anime_count
+    if moving? && @walk_anime
+      @anime_count += 1.5
+    elsif @step_anime || @pattern != @original_pattern
+      @anime_count += 1
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Update Animation Pattern
+  #--------------------------------------------------------------------------
+  def update_anime_pattern
+    if !@step_anime && @stop_count > 0
+      @pattern = @original_pattern
+    else
+      @pattern = (@pattern + 1) % 4
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Ladder
+  #--------------------------------------------------------------------------
+  def ladder?
+    $game_map.ladder?(@x, @y)
+  end
+  #--------------------------------------------------------------------------
+  # * Update Bush Depth
+  #--------------------------------------------------------------------------
+  def update_bush_depth
+    if normal_priority? && !object_character? && bush? && !jumping?
+      @bush_depth = 8 unless moving?
+    else
+      @bush_depth = 0
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Bush
+  #--------------------------------------------------------------------------
+  def bush?
+    $game_map.bush?(@x, @y)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Terrain Tag
+  #--------------------------------------------------------------------------
+  def terrain_tag
+    $game_map.terrain_tag(@x, @y)
+  end
+  #--------------------------------------------------------------------------
+  # * Get Region ID
+  #--------------------------------------------------------------------------
+  def region_id
+    $game_map.region_id(@x, @y)
+  end
+  #--------------------------------------------------------------------------
+  # * Increase Steps
+  #--------------------------------------------------------------------------
+  def increase_steps
+    set_direction(8) if ladder?
+    @stop_count = 0
+    update_bush_depth
+  end
+  #--------------------------------------------------------------------------
+  # * Change Graphics
+  #     character_name  : new character graphic filename
+  #     character_index : new character graphic index
+  #--------------------------------------------------------------------------
+  def set_graphic(character_name, character_index)
+    @tile_id = 0
+    @character_name = character_name
+    @character_index = character_index
+    @original_pattern = 1
+  end
+  #--------------------------------------------------------------------------
+  # * Determine Triggering of Frontal Touch Event
+  #--------------------------------------------------------------------------
+  def check_event_trigger_touch_front
+    x2 = $game_map.round_x_with_direction(@x, @direction)
+    y2 = $game_map.round_y_with_direction(@y, @direction)
+    check_event_trigger_touch(x2, y2)
+  end
+  #--------------------------------------------------------------------------
+  # * Determine if Touch Event is Triggered
+  #--------------------------------------------------------------------------
+  def check_event_trigger_touch(x, y)
+    return false
+  end
+  #--------------------------------------------------------------------------
+  # * Move Straight
+  #     d:        Direction (2,4,6,8)
+  #     turn_ok : Allows change of direction on the spot
+  #--------------------------------------------------------------------------
+  def move_straight(d, turn_ok = true)
+    @move_succeed = passable?(@x, @y, d)
+    if @move_succeed
+      set_direction(d)
+      @x = $game_map.round_x_with_direction(@x, d)
+      @y = $game_map.round_y_with_direction(@y, d)
+      @real_x = $game_map.x_with_direction(@x, reverse_dir(d))
+      @real_y = $game_map.y_with_direction(@y, reverse_dir(d))
+      increase_steps
+    elsif turn_ok
+      set_direction(d)
+      check_event_trigger_touch_front
+    end
+  end
+  #--------------------------------------------------------------------------
+  # * Move Diagonally
+  #     horz:  Horizontal (4 or 6)
+  #     vert:  Vertical (2 or 8)
+  #--------------------------------------------------------------------------
+  def move_diagonal(horz, vert)
+    @move_succeed = diagonal_passable?(x, y, horz, vert)
+    if @move_succeed
+      @x = $game_map.round_x_with_direction(@x, horz)
+      @y = $game_map.round_y_with_direction(@y, vert)
+      @real_x = $game_map.x_with_direction(@x, reverse_dir(horz))
+      @real_y = $game_map.y_with_direction(@y, reverse_dir(vert))
+      increase_steps
+    end
+    set_direction(horz) if @direction == reverse_dir(horz)
+    set_direction(vert) if @direction == reverse_dir(vert)
+  end
+end