Cogwheel's Pixel Movement

This script allows the player to move in 8 directions (without the need of an 8 way graphic) AND also allows them to move pixel-by-pixel instead of square by square. The only problem is that it IS limited by your passability, in that if you make a square impassible, even if it is just a tiny tree trunk that doesn't cover the entire square, the character will still be unable to move along that square. This was made by Cogwheel!

Paste this code above Main but under Scene_Debug:

[spoiler=Cogwheels Pixel Movement Script]

# [url="http://members.jcom.home.ne.jp/cogwheel/"]http://members.jcom.home.ne.jp/cogwheel/[/url]
#==============================================================================
# Game_Player
#==============================================================================
class Game_Player < Game_Character
UP    = 0
DOWN  = 0
SIDE  = 0
SLANT = false
#--------------------------------------------------------------------------
attr_reader   :event
attr_accessor :move_speed
#--------------------------------------------------------------------------
alias :update_original :update
def update
 @walk  = 4
 @dash  = 5
 @event = 4
 @dot_m = true
 unless moving? or $game_system.map_interpreter.running? or
         @move_route_forcing or $game_temp.message_window_showing
   if @walk != @dash
     if Input.press?(Input::C)
       if @move_speed != @dash
         @move_speed = @dash
       end
     else
       if @move_speed != @walk
         @move_speed = @walk
       end
     end
   end
 end
 if @revise_x == nil and @revise_y == nil
   @revise_x = 0
   @revise_y = 0
 end
 unless @dot_m
   update_original
   return
 end
 if @move_route_forcing
   last_moving = moving?
   last_real_x = @real_x
   last_real_y = @real_y
   if (@revise_x != 0 or @revise_y != 0) and not jumping? and @move == true
     if @revise_x != @real_x - @x * 128 or @revise_y != @real_y - @y * 128
       @revise_x = @real_x - @x * 128
       @revise_y = @real_y - @y * 128
     end
     distance1 = 2 ** @move_speed
     distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
     if distance1 > distance2
       @real_x = @real_x - @revise_x
       @real_y = @real_y - @revise_y
       @revise_x = 0
       @revise_y = 0
       anime_update
     else
       @real_x -= (distance1 * @revise_x / distance2).round
       @real_y -= (distance1 * @revise_y / distance2).round
       @revise_x = @real_x - @x * 128
       @revise_y = @real_y - @y * 128
       anime_update
     end
   else
     super
   end
 else
   @move = false
   unless moving? or $game_system.map_interpreter.running? or
          @move_route_forcing or $game_temp.message_window_showing
     @event_run = false
     case Input.dir8
     when 1
       move_lower_left_p
     when 2
       move_down_p
     when 3
       move_lower_right_p
     when 4
       move_left_p
     when 6
       move_right_p
     when 7
       move_upper_left_p
     when 8
       move_up_p
     when 9
       move_upper_right_p
     end
   end
   last_real_x = @real_x
   last_real_y = @real_y
   @real_x = @x * 128 + @revise_x
   @real_y = @y * 128 + @revise_y
   last_moving = moving?
   move_on
   if (last_real_x != @real_x or last_real_y != @real_y)
     @move_distance = 0 if @move_distance == nil
     @move_distance += Math.sqrt((last_real_x - @real_x) ** 2 +
                                   (last_real_y - @real_y) ** 2)
     if @move_distance >= 128
       @move_distance %= 128
       increase_steps
     end
     anime_update
   else
     @pattern = 0
   end
 end
 if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
   $game_map.scroll_down(@real_y - last_real_y)
 end
 if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
   $game_map.scroll_left(last_real_x - @real_x)
 end
 if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
   $game_map.scroll_right(@real_x - last_real_x)
 end
 if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
   $game_map.scroll_up(last_real_y - @real_y)
 end
 if last_moving
   result = check_event_trigger_here([1,2])
   if result == false
     unless $DEBUG and Input.press?(Input::CTRL)
       if @encounter_count > 0
         @encounter_count -= 1
       end
     end
   end
 end
 if Input.trigger?(Input::C)
   check_event_trigger_here([0])
   check_event_trigger_there([0,1,2])
 end
end
#--------------------------------------------------------------------------
def initialize
 @revise_x = 0
 @revise_y = 0
 @move == false
 super
end
#--------------------------------------------------------------------------
def moving?
 unless @dot_m
   result = super
   return result
 end
 if @move_route_forcing
   if @move == false
     return false
   end
   super
 else
   return (@x != (@real_x / 128.0).round or @y != (@real_y / 128.0).round)
 end
end
#--------------------------------------------------------------------------
def moving_a?
 if @move == false
   if (@move_route.list[@move_route_index].code <= 14 or
       @move_route.list[@move_route_index].code == 25)
     @move = true
   end
   return false
 end
 moving?
end
#--------------------------------------------------------------------------
def update_jump
 @jump_count -= 1
 @real_x = (@real_x * @jump_count + @x * 128) / (@jump_count + 1)
 @real_y = (@real_y * @jump_count + @y * 128) / (@jump_count + 1)
 if @jump_count == 0
   @revise_x = 0
   @revise_y = 0
 end
end
#--------------------------------------------------------------------------
def move_type_custom
 unless @dot_m
   super
   return
 end
 if jumping? or moving_a?
   return
 end
 while @move_route_index < @move_route.list.size
   command = @move_route.list[@move_route_index]
   if command.code == 0
     if @move_route.repeat
       @move_route_index = 0
     end
     unless @move_route.repeat
       if @move_route_forcing and not @move_route.repeat
         @move_route_forcing = false
         @move_route = @original_move_route
         @move_route_index = @original_move_route_index
         @original_move_route = nil
       end
       @stop_count = 0
     end
     return
   end
   if command.code <= 14
     case command.code
     when 1
       move_down
     when 2
       move_left
     when 3
       move_right
     when 4
       move_up
     when 5
       move_lower_left
     when 6
       move_lower_right
     when 7
       move_upper_left
     when 8
       move_upper_right
     when 9
       move_random
     when 10
       move_toward_player
     when 11
       move_away_from_player
     when 12
       move_forward
     when 13
       move_backward
     when 14
       jump(command.parameters[0], command.parameters[1])
     end
     if not @move_route.skippable and not moving? and not jumping?
       return
     end
     @move_route_index += 1
     return
   end
   if command.code == 15
     @wait_count = command.parameters[0] * 2 - 1
     @move_route_index += 1
     return
   end
   if command.code >= 16 and command.code <= 26
     case command.code
     when 16
       turn_down
     when 17
       turn_left
     when 18
       turn_right
     when 19
       turn_up
     when 20
       turn_right_90
     when 21
       turn_left_90
     when 22
       turn_180
     when 23
       turn_right_or_left_90
     when 24
       turn_random
     when 25
       turn_toward_player
     when 26
       turn_away_from_player
     end
     @move_route_index += 1
     return
   end
   if command.code >= 27
     case command.code
     when 27
       $game_switches[command.parameters[0]] = true
       $game_map.need_refresh = true
     when 28
       $game_switches[command.parameters[0]] = false
       $game_map.need_refresh = true
     when 29
       @move_speed = command.parameters[0]
     when 30
       @move_frequency = command.parameters[0]
     when 31
       @walk_anime = true
     when 32
       @walk_anime = false
     when 33
       @step_anime = true
     when 34
       @step_anime = false
     when 35
       @direction_fix = true
     when 36
       @direction_fix = false
     when 37
       @through = true
     when 38
       @through = false
     when 39
       @always_on_top = true
     when 40
       @always_on_top = false
     when 41
       @tile_id = 0
       @character_name = command.parameters[0]
       @character_hue = command.parameters[1]
       if @original_direction != command.parameters[2]
         @direction = command.parameters[2]
         @original_direction = @direction
         @prelock_direction = 0
       end
       if @original_pattern != command.parameters[3]
         @pattern = command.parameters[3]
         @original_pattern = @pattern
       end
     when 42
       @opacity = command.parameters[0]
     when 43
       @blend_type = command.parameters[0]
     when 44
       $game_system.se_play(command.parameters[0])
     when 45
       result = eval(command.parameters[0])
     end
     @move_route_index += 1
     return
   end
 end
end
#--------------------------------------------------------------------------
def move_down_p
 turn_down
 distance = 2 ** @move_speed
 down1(((@x * 128 + @revise_x) / 128.0).round,
       ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def down1(x, y, distance, down = false)
 result = down2(x, y, distance)
 if result == false
   @event_run = check_event_trigger_touch(x, y+1)
   return result
 end
 if @revise_x < -SIDE
   result = down2(x, y + 1, distance, 4)
   result &= down2(x - 1, y, distance)
   if result == false
     if down
       move_lower_right_p
       if @revise_x > SIDE
         @revise_x = SIDE
       end
     end
     return result
   end
 elsif @revise_x > SIDE
   result = down2(x, y + 1, distance, 6)
   result &= down2(x + 1, y, distance)
   if result == false
     if down
       move_lower_left_p
       if @revise_x < -SIDE
         @revise_x = -SIDE
       end
     end
     return result
   end
 end
 @revise_y += distance
 return result
end
#--------------------------------------------------------------------------
def down2(x, y, distance, d = 2)
 if @revise_y + distance > DOWN
   unless passable?(x, y, d)
     if @revise_y < DOWN
       @revise_y = DOWN
     end
     return false
   end
 end
 return true
end
#--------------------------------------------------------------------------
def move_left_p
 turn_left
 distance = 2 ** @move_speed
 left1(((@x * 128 + @revise_x) / 128.0).round,
       ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def left1(x, y, distance, left = false)
 result = left2(x, y, distance)
 if result == false
   @event_run = check_event_trigger_touch(x-1, y)
   return result
 end
 if @revise_y < -UP
   result = left2(x - 1, y, distance, 8)
   result &= left2(x, y - 1, distance)
   if result == false
     if left
       move_lower_left_p
       if @revise_y > DOWN
         @revise_y = DOWN
       end
     end
     return result
   end
 elsif @revise_y > DOWN
   result = left2(x - 1, y, distance, 2)
   result &= left2(x, y + 1, distance)
   if result == false
     if left
       move_upper_left_p
       if @revise_y < -UP
         @revise_y = -UP
       end
     end
     return result
   end
 end
 @revise_x -= distance
 return result
end
#--------------------------------------------------------------------------
def left2(x, y, distance, d = 4)
 if @revise_x - distance < -SIDE
   unless passable?(x, y, d)
     if @revise_x > -SIDE
       @revise_x = -SIDE
     end
     return false
   end
 end
 return true
end
#--------------------------------------------------------------------------
def move_right_p
   turn_right
 distance = 2 ** @move_speed
 right1(((@x * 128 + @revise_x) / 128.0).round,
         ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def right1(x, y, distance, right = false)
 result = right2(x, y, distance)
 if result == false
   @event_run = check_event_trigger_touch(x+1, y)
   return result
 end
 if @revise_y < -UP
   result = right2(x + 1, y, distance, 8)
   result &= right2(x, y - 1, distance)
   if result == false
     if right
       move_lower_right_p
       if @revise_y > DOWN
         @revise_y = DOWN
       end
     end
     return result
   end
 elsif @revise_y > DOWN
   result = right2(x + 1, y, distance, 2)
   result &= right2(x, y + 1, distance)
   if result == false
     if right
       move_upper_right_p
       if @revise_y < -UP
         @revise_y = -UP
       end
     end
     return result
   end
 end
 @revise_x += distance
 return result
end
#--------------------------------------------------------------------------
def right2(x, y, distance, d = 6)
 if @revise_x + distance > SIDE
   unless passable?(x, y, d)
     if @revise_x < SIDE
       @revise_x = SIDE
     end
     return false
   end
 end
 return true
end
#--------------------------------------------------------------------------
def move_up_p
 turn_up
 distance = 2 ** @move_speed
 up1(((@x * 128 + @revise_x) / 128.0).round,
     ((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
def up1(x, y, distance, up = false)
 result = up2(x, y, distance)
 if result == false
   @event_run = check_event_trigger_touch(x, y-1)
   return result
 end
 if @revise_x < -SIDE
   result = up2(x, y - 1, distance, 4)
   result &= up2(x - 1, y, distance)
   if result == false
     if up
       move_upper_right_p
       if @revise_x > SIDE
         @revise_x = SIDE
       end
     end
     return result
   end
 elsif @revise_x > SIDE
   result = up2(x, y - 1, distance, 6)
   result &= up2(x + 1, y, distance)
   if result == false
     if up
       move_upper_left_p
       if @revise_x < -SIDE
         @revise_x = -SIDE
       end
     end
     return result
   end
 end
 @revise_y -= distance
 return result
end
#--------------------------------------------------------------------------
def up2(x, y, distance, d = 8)
 if @revise_y - distance < -UP
   unless passable?(x, y, d)
     if @revise_y > -UP
       @revise_y = -UP
     end
     return false
   end
 end
 return true
end
#--------------------------------------------------------------------------
def move_lower_left_p
 unless @direction_fix
   @direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
 end
 distance = (2 ** @move_speed) / Math.sqrt(2)
 turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
                         ((@y * 128 + @revise_y) / 128.0).round, distance)
 turn_down if @event_run
 unless @event_run
   if last_move?(@real_x, @real_y, 2, distance)
     result = check_event_trigger_here([1,2], false)
     if result == true
       return
     end
   end
   move_on
   if @revise_y > DOWN and -UP > @revise_y - distance
     @revise_y = DOWN
   end
   turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
                         ((@y * 128 + @revise_y) / 128.0).round, distance)
   turn_left if @event_run
 end
end
#--------------------------------------------------------------------------
def move_lower_right_p
 unless @direction_fix
   @direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
 end
 distance = (2 ** @move_speed) / Math.sqrt(2)
 turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
                         ((@y * 128 + @revise_y) / 128.0).round, distance)
 turn_down if @event_run
 unless @event_run
   if last_move?(@real_x, @real_y, 2, distance)
     result = check_event_trigger_here([1,2], false)
     if result == true
       return
     end
   end
   move_on
   if @revise_y > DOWN and -UP > @revise_y - distance
     @revise_y = DOWN
   end
   turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
                         ((@y * 128 + @revise_y) / 128.0).round, distance)
   turn_right if @event_run
 end
end
#--------------------------------------------------------------------------
def move_upper_left_p
 unless @direction_fix
   @direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
 end
 distance = (2 ** @move_speed) / Math.sqrt(2)
 turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
                       ((@y * 128 + @revise_y) / 128.0).round, distance)
 turn_up if @event_run
 unless @event_run
   if last_move?(@real_x, @real_y, 8, distance)
     result = check_event_trigger_here([1,2], false)
     if result == true
       return
     end
   end
   move_on
   if @revise_y + distance > DOWN and -UP > @revise_y
     @revise_y = -UP
   end
   turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
                         ((@y * 128 + @revise_y) / 128.0).round, distance)
   turn_left if @event_run
 end
end
#--------------------------------------------------------------------------
def move_upper_right_p
 unless @direction_fix
   @direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
 end
 distance = (2 ** @move_speed) / Math.sqrt(2)
 turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
                       ((@y * 128 + @revise_y) / 128.0).round, distance)
 turn_up if @event_run
 unless @event_run
   if last_move?(@real_x, @real_y, 8, distance)
     result = check_event_trigger_here([1,2], false)
     if result == true
       return
     end
   end
   move_on
   if @revise_y + distance > DOWN and -UP > @revise_y
     @revise_y = -UP
   end
   turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
                         ((@y * 128 + @revise_y) / 128.0).round, distance)
   turn_right if @event_run
 end
end
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers, run = true)
 result = false
 if $game_system.map_interpreter.running?
   return result
 end
 for event in $game_map.events.values
   if event.x == ((@x * 128 + @revise_x) / 128.0).round and
       event.y == ((@y * 128 + @revise_y) / 128.0).round and
       triggers.include?(event.trigger)
     if not event.jumping? and event.over_trigger?
       if event.list.size > 1
         if run == true
           event.start
         end
         result = true
       end
     end
   end
 end
 return result
end
#--------------------------------------------------------------------------
def move_on
 if @y < (@y + @revise_y / 128.0).round
   @y += 1
   @revise_y -= 128
 end
 if @x > (@x + @revise_x / 128.0).round
   @x -= 1
   @revise_x += 128
 end
 if @x < (@x + @revise_x / 128.0).round
   @x += 1
   @revise_x -= 128
 end
 if @y > (@y + @revise_y / 128.0).round
   @y -= 1
   @revise_y += 128
 end
end
#--------------------------------------------------------------------------
def anime_update
 if @walk_anime
   @anime_count += 1.5
 elsif @step_anime
   @anime_count += 1
 end
 if @anime_count > 18 - @move_speed * 2
   if not @step_anime and @stop_count > 0
     @pattern = @original_pattern
   else
     @pattern = (@pattern + 1) % 4
   end
   @anime_count = 0
 end
end
#--------------------------------------------------------------------------
alias :moveto_original :moveto
def moveto(x, y)
 @revise_x = 0
 @revise_y = 0
 moveto_original(x, y)
end
#--------------------------------------------------------------------------
def last_move?(x, y, direction, distance)
 if direction == 2 or direction == 6
   distance *= -1
 end
 if (direction == 2 or direction == 8) and
     (y / 128.0).round != ((y - distance) / 128.0).round
   return true
 end
 if (direction == 4 or direction == 6) and
     (x / 128.0).round != ((x - distance) / 128.0).round
   return true
 end
 return false
end
end

#==============================================================================
# Game_Character
#==============================================================================
class Game_Character
def update_move
 distance = 2 ** @move_speed
 if @x * 128 != @real_x and @y * 128 != @real_y and Game_Player::SLANT
   distance /= Math.sqrt(2)
 end
 if @y * 128 > @real_y
   @real_y = [@real_y + distance, @y * 128].min
 end
 if @x * 128 < @real_x
   @real_x = [@real_x - distance, @x * 128].max
 end
 if @x * 128 > @real_x
   @real_x = [@real_x + distance, @x * 128].min
 end
 if @y * 128 < @real_y
   @real_y = [@real_y - distance, @y * 128].max
 end
 if @walk_anime
   @anime_count += 1.5
 elsif @step_anime
   @anime_count += 1
 end
end
end
#==============================================================================
# Game_Event
#==============================================================================
class Game_Event < Game_Character
def start
 if @list.size > 1
   if $game_player.event != 0
     $game_player.move_speed = $game_player.event
   end
   @starting = true
 end
end
end

[info=Support Topic]http://www.rmxpunlimited.net/forums/index.php?showtopic=162[/info]