Cogwheel's Px Movement + XRXS's platformer script integration.

[PK8]

I'm having trouble with Cogwheel's Pixel Movement script. I'm using XRXS's platformer, which is something I totally need for my project. Platformer Script can be found here. I found Cogwheel's Pixel Movement here (sorry, offsite link). I'll post it here.

Spoiler: Cogwheel's Pixel Movement Script

# http://members.jcom.home.ne.jp/cogwheel/
#==============================================================================
# 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

So I'm trying to add Cogwheel's Pixel Movement script into this project I'm working on and I'm having a bit of trouble. When attempting to jump, the player would jump and fall at the blink of an eye, which is something I don't want the character to be doing. So now I'm wondering, is there a fix to that?