Move Route glitch with Pixel Movement

mylafter

I’m a creep... I’m a weirdo...
Veteran
Joined
Dec 30, 2012
Messages
185
Reaction score
113
First Language
English
Primarily Uses
N/A
I want to apologize in advance if creating a new thread may seem pesky but I created a thread with this same problem a year ago. I would go and bump it but I think it be best to start a new thread since the issue was never solved. Plus, I'm back with(hopefully) a way to help solve it? For reference, the previous thread can be found here: https://forums.rpgmakerweb.com/index.php?threads/move-route-glitch-with-pixel-movement.104625/#post-937428

So I am using Victor's Pixel Movement. Found here: https://victorenginescripts.wordpress.com/rpg-maker-vx-ace/pixel-movement/comment-page-1/
The problem occurs when you set a move route for an event. If you go and interrupt their move route, they will start it over and repeat the same movement, causing the placement of their movement to shift and loop all over the map, sometimes even getting stuck. For example, if there is an event that moves left 3 times and right 3 times. If the player walks in and interrupts the moveset, the event will revert back to the beginning and start the movement all over again.

I stumbled upon Khas' Pixel Movement which doesn't have this issue.
The demo which includes the script can be downloaded here: http://www.mediafire.com/file/x5pxqmvw59be3zh/%5BACE%5D%5BEN%5D_Khas_Pixel_Movement_1.2.rar/file
The move route for Khas' script works normally. Which got me thinking, maybe there's something in Khas' script that could give a clue to fixing Victor's. I know it would make sense to switch over to Khas' script instead but Victor's script has different configuration settings that fit my project better. And I know scripts are all coded differently, but in my past thread, we couldn't find a solution to the problem. So I'm simply saying, perhaps Khas' script could provide help.

If Khas' script doesn't provide a solution, I still hope to find a way to still fix this issue.

EDIT: Here's a demo demonstrating the issue. The demo has two scripts. The main script with the issue is called "Pixel Movement," while the other one is mainly the Engine/Basic Module. So, don't mind it.
 
Last edited:

Bex

Veteran
Veteran
Joined
Aug 2, 2013
Messages
1,350
Reaction score
332
First Language
German
Primarily Uses
RMMV
I dont know about the Scripts but
the standard editor also behaves like that, its because of the "skip if cannot move" box.
If you do not mark it, the Event will just wait until the player or another Event does not block the path and than the event continues where it stoped.
The Problem with this is: If a Event trys to move to somewhere it cant move to, it will get stuck.
It could also crash the Game. So if i remember correctly this does not work well with random movement.
I dont know if the Pixel Scripts change this behavior.
 

mylafter

I’m a creep... I’m a weirdo...
Veteran
Joined
Dec 30, 2012
Messages
185
Reaction score
113
First Language
English
Primarily Uses
N/A
Well, I don't have the 'Skip if cannot move' box checked. But I'm pretty sure the script does change the way the standard edition behaves. The issue still occurs whether the 'repeat' or 'skip' boxes are checked or not. (Whether both or either are checked, the issue still occurs.)
 

mylafter

I’m a creep... I’m a weirdo...
Veteran
Joined
Dec 30, 2012
Messages
185
Reaction score
113
First Language
English
Primarily Uses
N/A

mylafter

I’m a creep... I’m a weirdo...
Veteran
Joined
Dec 30, 2012
Messages
185
Reaction score
113
First Language
English
Primarily Uses
N/A

Morpheus

Jack-of-Trades
Veteran
Joined
Mar 14, 2012
Messages
139
Reaction score
13
First Language
english
Primarily Uses
N/A
Wow, I've been using this script for awhile before you pointed this out. I'm already too deep into development to change scripts but luckily nothing in my game will require this to be fixed but yeah, can confirm it does the same thing for me when I try. Here's a bump to hoping it gets fixed/patched.
 

Christopher Riel

Villager
Member
Joined
Jul 17, 2017
Messages
24
Reaction score
0
First Language
Spanish
Primarily Uses
RMVXA
here fix the problem a bit, when the character collides with an event, the movement path is no longer repeated until the player goes out of his way, however (I am not very expert in code)
Now the movement route respects the pixels because I have deactivated the "step_times" method that when placing a movement route page is multiplying them by 8, But not now. therefore more actions in the move route would be needed for the event to move in 32 pixels.

the modification I made was to replace the "move straight" and "move_diagonal" method with that of RPG Maker
I hope it is some help for you.

Ruby:
#==============================================================================
# ** Victor Engine - Pixel Movement
#------------------------------------------------------------------------------
# Author : Victor Sant
#
# Version History:
#  v 1.00 - 2012.05.29 > First release
#  v 1.01 - 2012.05.29 > Compatibility with Terrain States
#  v 1.02 - 2012.07.03 > Compatibility with Basic Module 1.23
#  v 1.03 - 2012.07.05 > Added 'over event' tag for objects over blocked tiles
#                      > Added Steps settings for events
#  v 1.04 - 2012.07.24 > Compatibility with Moving Platform
#                      > Added <each step trigger> tag for events
#  v 1.05 - 2012.07.30 > Fixed issue when characters moves toward the same spot
#  v 1.06 - 2012.08.03 > Compatibility with Anti Lag
#  v 1.07 - 2012.08.03 > Fixed collision with tile graphics events
#  v 1.08 - 2012.08.18 > Fixed issue with Pixel Movement and Vehicles
#                      > Fixed issue with some notetags
#                      > Fixed issue with chasing events
#  v 1.09 - 2013.01.07 > Fixed issue with vehicles passing through all tiles
#  v 1.10 - 2013.01.24 > Fixed issue with diagonal movement and VE_DIAGONAL_FIX
#------------------------------------------------------------------------------
#  This script allows to replace the tile based movement where the player
# walks a whole 32 pixel tile each step with one that he walks only 4 pixels.
# It also give a better collision system for events.
#------------------------------------------------------------------------------
# Compatibility
#   Requires the script 'Victor Engine - Basic Module' v 1.25 or higher
#   If used with 'Victor Engine - Animated Battle' place this bellow it.
#   If used with 'Victor Engine - Follower Control' place this bellow it.
#   If used with 'Victor Engine - Follower Options' place this bellow it.
#
# * Overwrite methods
#   class Game_Actor < Game_Battler
#     def turn_end_on_map
#
#   class Game_Map
#     def layered_tiles(x, y)
#     def events_xy(x, y)
#     def events_xy_nt(x, y)
#     def x_with_direction(x, d, times = 1)
#     def y_with_direction(y, d, times = 1)
#     def round_x_with_direction(x, d)
#     def round_y_with_direction
#
#   class Game_CharacterBase
#     def region_id
#     def move_straight(d, turn_ok = true)
#     def move_diagonal(horz, vert)
#     def collide_with_events?(x, y)
#     def collide_with_vehicles?(x, y)
#
#   class Game_Player < Game_Character
#     def check_event_trigger_there(triggers)
#     def start_map_event(x, y, triggers, normal)
#     def update_nonmoving(last_moving)
#     def get_on_vehicle
#     def increase_steps
#
#   class Game_Follower < Game_Character
#     def chase_preceding_character
#
#   class Game_Event < Game_Character
#     def collide_with_player_characters?(x, y)
#
#   class Game_Vehicle < Game_Character
#     def land_ok?(x, y, d)
#
# * Alias methods
#   class Game_Actor < Game_Battler
#     def check_floor_effect
#
#   class Game_CharacterBase
#     def init_public_members
#     def update
#
#   class Game_Event < Game_Character
#     def start
#
#   class Game_Player < Game_Character
#     def get_off_vehicle
#     def clear_transfer_info
#     def update
#
#   class Game_Event < Game_Character
#     def start
#
#------------------------------------------------------------------------------
# Instructions:
#  To instal the script, open you script editor and paste this script on
#  a new section bellow the Materials section. This script must also
#  be bellow the script 'Victor Engine - Basic'
#
#------------------------------------------------------------------------------
# Event Comment boxes note tags:
#   Tags to be used on events Comment boxes.
#
#  <move steps: x>
#   Setup the number of steps each "Move" command will execute. The default
#   value is 8 (1 tile)
#     x : number of steps
#
#  <event size: x, y>
#   Collision area size, in pixels for event collisions.
#     x : collision area width
#     y : collision area height
#
#  <front collision>
#   Events with this tag won't start if the the collision between events and
#   the player occur between their edges.
#
#  <no side collision fix>
#   Events with this tag won't have the "slide" effect when the edges of the
#   events collide with the player
#
#  <over tile>
#   Events with this tag will start even when placed over blocked tiles.
#   By default, if the passage is blocked the event don't start.
#
#  <each step trigger>
#   By default, events with through or bellow character priority triggers
#   only one time for each 8 steps above them. With this tag though, the
#   event will trigger every step.
#
#------------------------------------------------------------------------------
# Additional instructions:
#
#  All events and tiles have a "slide" effect when the player faces the edge
#  of a tile or event. I added this function since it would be a pain to
#  be in the exact position to go throug a narrow path.
#  This can be disabled for events, but not for tiles.
#
#  By default, event collision size is the same as the event bitmap box, no
#  matter how the sprite is set inside of the box. If you want different
#  collision size you must setup manually in the event with the tag
#  <event size: x, y>
#
#  Events over blocked tiles will not start properly unless the event have
#  the tag <over tile>
#
#==============================================================================

#==============================================================================
# ** Victor Engine
#------------------------------------------------------------------------------
#   Setting module for the Victor Engine
#==============================================================================

module Victor_Engine
  #--------------------------------------------------------------------------
  # * Player collision area
  #   Different from events, player collision don't rely on the graphic size
  #   Player collision area can be of 2 types:
  #   - 32 x 32 box if VE_PLAYER_BIG_COLLISION = true
  #   - 24 x 24 box if VE_PLAYER_BIG_COLLISION = false
  #--------------------------------------------------------------------------
  VE_PLAYER_BIG_COLLISION = true
  #--------------------------------------------------------------------------
  # * required
  #   This method checks for the existance of the basic module and other
  #   VE scripts required for this script to work, don't edit this
  #--------------------------------------------------------------------------
  def self.required(name, req, version, type = nil)
    if !$imported[:ve_basic_module]
      msg = "The script '%s' requires the script\n"
      msg += "'VE - Basic Module' v%s or higher above it to work properly\n"
      msg += "Go to http://victorenginescripts.wordpress.com/ to download this script."
      msgbox(sprintf(msg, self.script_name(name), version))
      exit
    else
      self.required_script(name, req, version, type)
    end
  end
  #--------------------------------------------------------------------------
  # * script_name
  #   Get the script name base on the imported value
  #--------------------------------------------------------------------------
  def self.script_name(name, ext = "VE")
    name = name.to_s.gsub("_", " ").upcase.split
    name.collect! {|char| char == ext ? "#{char} -" : char.capitalize }
    name.join(" ")
  end
end

$imported ||= {}
$imported[:ve_pixel_movement] = 1.10
Victor_Engine.required(:ve_pixel_movement, :ve_basic_module, 1.25, :above)
Victor_Engine.required(:ve_pixel_movement, :ve_map_battle, 1.00, :bellow)
Victor_Engine.required(:ve_pixel_movement, :ve_diagonal_move, 1.00, :bellow)

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # * Overwrite method: turn_end_on_map
  #--------------------------------------------------------------------------
  def turn_end_on_map
    if $game_player.steps % (steps_for_turn * 8) == 0
      on_turn_end
      perform_map_damage_effect if @result.hp_damage > 0
    end
  end
  #--------------------------------------------------------------------------
  # * Alias method: init_public_members
  #--------------------------------------------------------------------------
  alias :check_floor_effect_ve_pixel_movement :check_floor_effect
  def check_floor_effect
    return if check_damage_floor
    check_floor_effect_ve_pixel_movement
  end
  #--------------------------------------------------------------------------
  # * New method: check_damage_floor
  #--------------------------------------------------------------------------
  def check_damage_floor
    $game_player.damage_floor % 8 != 0
  end
end

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  This class handles maps. It includes scrolling and passage determination
# functions. The instance of this class is referenced by $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Overwrite method: layered_tiles
  #--------------------------------------------------------------------------
  def layered_tiles(x, y)
    x2 = (x - 0.5).ceil
    y2 = (y - 0.125).ceil
    [2, 1, 0].collect {|z| tile_id(x2, y2, z) }
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: events_xy
  #--------------------------------------------------------------------------
  def events_xy(x, y)
    event_list.select {|event| event.near?(x, y) }
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: events_xy_nt
  #--------------------------------------------------------------------------
  def events_xy_nt(x, y)
    event_list.select {|event| event.near_nt?(x, y) }
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: x_with_direction
  #--------------------------------------------------------------------------
  def x_with_direction(x, d, times = 1)
    x + (d == 6 ? times * 0.125 : d == 4 ? -times * 0.125 : 0)
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: y_with_direction
  #--------------------------------------------------------------------------
  def y_with_direction(y, d, times = 1)
    y + (d == 2 ? times * 0.125 : d == 8 ? -times * 0.125 : 0)
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: round_x_with_direction
  #--------------------------------------------------------------------------
  def round_x_with_direction(x, d)
    round_x(x + (d == 6 ? 0.125 : d == 4 ? -0.125 : 0))
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: round_y_with_direction
  #--------------------------------------------------------------------------
  def round_y_with_direction(y, d)
    round_y(y + (d == 2 ? 0.125 : d == 8 ? -0.125 : 0))
  end
  #--------------------------------------------------------------------------
  # * New method: check_x_with_direction
  #--------------------------------------------------------------------------
  def check_x_with_direction(x, d)
    round_x(x + (d == 6 ? 1 : d == 4 ? -1 : 0))
  end
  #--------------------------------------------------------------------------
  # * New method: check_y_with_direction
  #--------------------------------------------------------------------------
  def check_y_with_direction(y, d)
    round_y(y + (d == 2 ? 1 : d == 8 ? -1 : 0))
  end
end

#==============================================================================
# ** Game_CharacterBase
#------------------------------------------------------------------------------
#  This class deals with characters. Common to all characters, stores basic
# data, such as coordinates and graphics. It's used as a superclass of the
# Game_Character class.
#==============================================================================

class Game_CharacterBase
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :next_movement
  attr_accessor :side_collision
  attr_accessor :damage_floor
  attr_accessor :move_list
  attr_accessor :steps
  #--------------------------------------------------------------------------
  # * Overwrite method: region_id
  #--------------------------------------------------------------------------
  def region_id
    $game_map.region_id((@x - 0.5).ceil, (@y - 0.125).ceil)
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: collide_with_events?
  #--------------------------------------------------------------------------
  def collide_with_events?(x, y)
    $game_map.events_xy_nt(x, y).any? do |event|
      event.collision_condition?(x, y, bw, bh, event?, @id, @side_collision)
    end
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: collide_with_vehicles?
  #--------------------------------------------------------------------------
  def collide_with_vehicles?(x, y)
    $game_map.vehicles.compact.any? do |vehicle|
      next if vehicle.map_id != $game_map.map_id
      vehicle.collision_condition?(x, y, bw, bh, self)
    end
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: move_straight
  #--------------------------------------------------------------------------
  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
  #--------------------------------------------------------------------------
  # * Overwrite method: move_straight
  #--------------------------------------------------------------------------
  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
  #--------------------------------------------------------------------------
  # * Alias method: init_public_members
  #--------------------------------------------------------------------------
  alias :init_public_members_ve_pixel_movement :init_public_members
  def init_public_members
    init_public_members_ve_pixel_movement
    @move_list     = []
    @next_movement = []
    @over_event    = 0
    @damage_floor  = 0
    @steps         = 0
  end
  #--------------------------------------------------------------------------
  # * Alias method: update
  #--------------------------------------------------------------------------
  alias :update_ve_pixel_movement :update
  def update
    update_move_straight
    update_move_diagonal
    update_ve_pixel_movement
  end
  #--------------------------------------------------------------------------
  # * New method: update_move_straight
  #--------------------------------------------------------------------------
  def update_move_straight
    return if moving? || @move_list.empty?
    return if @move_list.first[:d].size > 1
    @move_value = @move_list.shift
    d           = @move_value[:d].first
    if passable?(@x, @y, d)
      move_straight_pixel(d)
    elsif @move_value[:turn]
      @move_list.clear
      check_event_trigger_move(d)
    else
      @move_list.clear
    end
  end
  #--------------------------------------------------------------------------
  # * New method: move_straight_pixel
  #--------------------------------------------------------------------------
  def move_straight_pixel(d)
    @diagonal_move = false
    setup_movement(d, d)
    @real_x = $game_map.x_with_direction(@x, reverse_dir(d))
    @real_y = $game_map.y_with_direction(@y, reverse_dir(d))
    @moved  = player?
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: update_move_diagonal
  #--------------------------------------------------------------------------
  def update_move_diagonal
    return if moving? || @move_list.empty?
    return if @move_list.first[:d].size < 2
    @move_value = @move_list.shift
    horz        = @move_value[:d].first
    vert        = @move_value[:d].last
    move_diagonal_pixel(horz, vert) if diagonal_passable?(x, y, horz, vert)
  end
  #--------------------------------------------------------------------------
  # * New method: move_diagonal_pixel
  #--------------------------------------------------------------------------
  def move_diagonal_pixel(horz, vert)
    @diagonal_move = true
    setup_movement(horz, vert)
    @real_x = $game_map.x_with_direction(@x, reverse_dir(horz))
    @real_y = $game_map.y_with_direction(@y, reverse_dir(vert))
    @moved = player?
  end
  #--------------------------------------------------------------------------
  # * New method: character_collision?
  #--------------------------------------------------------------------------
  def character_collision?(x, y, d)
    x2 = $game_map.round_x_with_direction(x, d)
    y2 = $game_map.round_y_with_direction(y, d)
    @through || debug_through? || !collide_with_characters?(x2, y2)
  end
  #--------------------------------------------------------------------------
  # * New method: step_times
  #--------------------------------------------------------------------------
  def step_times
    return 8
  end
  #--------------------------------------------------------------------------
  # * New method: near_nt?
  #--------------------------------------------------------------------------
  def near_nt?(x, y)
    near?(x, y) && !@through
  end
  #--------------------------------------------------------------------------
  # * New method: near?
  #--------------------------------------------------------------------------
  def near?(x, y)
    w = step_over? ? [bw * 0.625, 0.5].max : [bw, 1.0].max
    h = step_over? ? [bh * 0.625, 0.5].max : [bh, 1.0].max
    @real_x > x - w && @real_x < x + w && @real_y > y - h && @real_y < y + h
  end
  #--------------------------------------------------------------------------
  # * New method: setup_movement
  #--------------------------------------------------------------------------
  def setup_movement(horz, vert)
    @x = $game_map.round_x_with_direction(@x, horz)
    @y = $game_map.round_y_with_direction(@y, vert)
    add_next_movement(horz == vert ? horz : [horz, vert])
    set_direction(horz) if @direction == reverse_dir(horz) || horz == vert
    set_direction(vert) if @direction == reverse_dir(vert) && horz != vert
    follower_control_move_update(horz, vert)
    increase_steps
  end
  #--------------------------------------------------------------------------
  # * New method: check_event_trigger_move
  #--------------------------------------------------------------------------
  def check_event_trigger_move(d)
    set_direction(d)
    check_event_trigger_touch_front
  end
  #--------------------------------------------------------------------------
  # * New method: collision_condition?
  #--------------------------------------------------------------------------
  def collision_condition?(x, y, bw, bh, event, event_id, side)
    return false if event && self.id == event_id
    return false unless collision?(x, y, bw, bh)
    return false unless normal_priority? || event
    return false if side && !side_collision?
    return true
  end
  #--------------------------------------------------------------------------
  # * New method: follower_control_move_update
  #--------------------------------------------------------------------------
  def follower_control_move_update(horz, vert)
    return unless $imported[:ve_followers_options]
    return unless player? || follower?
    add_move_update(horz == vert ? [horz] : [horz, vert])
  end
  #--------------------------------------------------------------------------
  # * New method: passable?
  #--------------------------------------------------------------------------
  def passable?(x, y, d)
    x = fix_position(x)
    y = fix_position(y)
    passable1 = passable_tile?(x, y, d)
    passable2 = character_collision?(x, y, d)
    fix_movement(x, y, d)  if player? && !passable1 && passable2
    fix_collision(x, y, d) if player? && !passable2 && passable1
    passable1 && passable2
  end
  #--------------------------------------------------------------------------
  # * New method: passable_tile?
  #--------------------------------------------------------------------------
  def passable_tile?(x, y, d)
    result = true
    result = passable_down?(x, y)  if d == 2
    result = passable_left?(x, y)  if d == 4
    result = passable_right?(x, y) if d == 6
    result = passable_up?(x, y)    if d == 8
    result
  end
  #--------------------------------------------------------------------------
  # * New method: locked_tile?
  #--------------------------------------------------------------------------
  def locked_tile?(x, y, d = 0)
    list = [2, 4, 6, 8] - [d]
    list.all? {|d| !map_passable?(x, y, d) }
  end
  #--------------------------------------------------------------------------
  # * New method: locked_move?
  #--------------------------------------------------------------------------
  def locked_move?(x, y)
    !passable_down?(x, y)  && !passable_left?(x, y)
    !passable_right?(x, y) && !passable_up?(x, y)
  end
  #--------------------------------------------------------------------------
  # * New method: passable_down?
  #--------------------------------------------------------------------------
  def passable_down?(x, y)
    passable_normal?(x.ceil, y.to_i, 2, 4, x.ceil?) &&
    passable_normal?(x.to_i, y.to_i, 2, 6, x.ceil?)
  end
  #--------------------------------------------------------------------------
  # * New method: passable_left?
  #--------------------------------------------------------------------------
  def passable_left?(x, y)
    passable_normal?(x.ceil, y.ceil, 4, 8, y.ceil?) &&
    passable_normal?(x.ceil, y.to_i, 4, 2, y.ceil?)
  end
  #--------------------------------------------------------------------------
  # * New method: passable_right?
  #--------------------------------------------------------------------------
  def passable_right?(x, y)
    passable_normal?(x.to_i, y.ceil, 6, 8, y.ceil?) &&
    passable_normal?(x.to_i, y.to_i, 6, 2, y.ceil?)
  end
  #--------------------------------------------------------------------------
  # * New method: passable_up?
  #--------------------------------------------------------------------------
  def passable_up?(x, y)
    passable_normal?(x.ceil, y.ceil, 8, 4, x.ceil?) &&
    passable_normal?(x.to_i, y.ceil, 8, 6, x.ceil?)
  end
  #--------------------------------------------------------------------------
  # * New method: passable_normal?
  #--------------------------------------------------------------------------
  def passable_normal?(x, y, d, d2, ceil = false)
    x1 = $game_map.round_x(x)
    y1 = $game_map.round_y(y)
    x2 = $game_map.check_x_with_direction(x1, d)
    y2 = $game_map.check_y_with_direction(y1, d)
    x3 = $game_map.round_x_with_direction(x1, d)
    y3 = $game_map.round_y_with_direction(y1, d)
    return false unless $game_map.valid?(x3, y3)
    return true  if @through || debug_through?
    return false unless map_passable?(x2, y2, d2) || !ceil
    return false unless move_passable1?(x1, y1, x2, y2, d)
    return false unless move_passable2?(x1, y1, x2, y2, d)
    return true
  end
  #--------------------------------------------------------------------------
  # * New method: move_passable1?
  #--------------------------------------------------------------------------
  def move_passable1?(x1, y1, x2, y2, d)
    map_passable?(x1, y1, d) || map_passable?(x2, y2, d)
  end
  #--------------------------------------------------------------------------
  # * New method: move_passable?
  #--------------------------------------------------------------------------
  def move_passable2?(x1, y1, x2, y2, d)
    map_passable?(x2, y2, reverse_dir(d)) && (map_passable?(x1, y1, d) ||
    locked_tile?(x1, y1))
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement
  #--------------------------------------------------------------------------
  def fix_movement(x, y, d)
    return if (@diagonal && @diagonal != 0) || @diagonal_move
    fix_movement_horiz(x, y, d) if (d == 2 || d == 8) && x.ceil?
    fix_movement_vert(x, y, d)  if (d == 4 || d == 6) && y.ceil?
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement_horiz
  #--------------------------------------------------------------------------
  def fix_movement_horiz(x, y, d)
    adjust = x - x.to_i
    fix_move_straight(4) if fix_movement_left?(x, y, d)  && adjust < 0.5
    fix_move_straight(6) if fix_movement_right?(x, y, d) && adjust > 0.5
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement_ver
  #--------------------------------------------------------------------------
  def fix_movement_vert(x, y, d)
    adjust = y - y.to_i
    fix_move_straight(2) if fix_movement_down?(x, y, d) && adjust > 0.5
    fix_move_straight(8) if fix_movement_up?(x, y, d)   && adjust < 0.5
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement_down?
  #--------------------------------------------------------------------------
  def fix_movement_down?(x, y, d)
    passable_normal?(x.to_i, y.ceil, d, 0, false) && movement_fix?(x, y, 2)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement_left?
  #--------------------------------------------------------------------------
  def fix_movement_left?(x, y, d)
    passable_normal?(x.to_i, y.to_i, d, 0, false) && movement_fix?(x, y, 4)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement_right?
  #--------------------------------------------------------------------------
  def fix_movement_right?(x, y, d)
    passable_normal?(x.ceil, y.to_i, d, 0, false) && movement_fix?(x, y, 6)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_movement_up?
  #--------------------------------------------------------------------------
  def fix_movement_up?(x, y, d)
    passable_normal?(x.to_i, y.to_i, d, 0, false) && movement_fix?(x, y, 8)
  end
  #--------------------------------------------------------------------------
  # * New method: movement_fix?
  #--------------------------------------------------------------------------
  def movement_fix?(x, y, d)
    passable_tile?(x, y, d) && character_collision?(x, y, d)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision
  #--------------------------------------------------------------------------
  def fix_collision(x, y, d)
    return if (@diagonal && @diagonal != 0) || @diagonal_move
    @side_collision = true
    fix_collision_horiz(x, y, d) if (d == 2 || d == 8)
    fix_collision_vert(x, y, d)  if (d == 4 || d == 6)
    @side_collision = false
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision_horiz
  #--------------------------------------------------------------------------
  def fix_collision_horiz(x, y, d)
    fix_move_straight(4) if fix_collision_left?(x, y, d)
    fix_move_straight(6) if fix_collision_right?(x, y, d)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision_vert
  #--------------------------------------------------------------------------
  def fix_collision_vert(x, y, d)
    fix_move_straight(2) if fix_collision_down?(x, y, d)
    fix_move_straight(8) if fix_collision_up?(x, y, d)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision_down?
  #--------------------------------------------------------------------------
  def fix_collision_down?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 2)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision_left?
  #--------------------------------------------------------------------------
  def fix_collision_left?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d,  4)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision_right?
  #--------------------------------------------------------------------------
  def fix_collision_right?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 6)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_collision_up?
  #--------------------------------------------------------------------------
  def fix_collision_up?(x, y, d)
    !character_collision?(x, y, d) && collision_fix?(x, y, d, 8)
  end
  #--------------------------------------------------------------------------
  # * New method: collision_fix?
  #--------------------------------------------------------------------------
  def collision_fix?(x, y, d, d2)
    side_collision_fix?(x, y, d, d2, 2) && side_fix?(x, y, d2)
  end
  #--------------------------------------------------------------------------
  # * New method: side_collision_fix?
  #--------------------------------------------------------------------------
  def side_collision_fix?(x, y, d, d2, t)
    t.times.any? do |i|
      x2, y2 = x, y
      y2 += (t - i) * 0.125 if d2 == 2
      x2 -= (t - i) * 0.125 if d2 == 4
      x2 += (t - i) * 0.125 if d2 == 6
      y2 -= (t - i) * 0.125 if d2 == 8
      character_collision?(x2, y2, d)
    end
  end
  #--------------------------------------------------------------------------
  # * New method: side_fix?
  #--------------------------------------------------------------------------
  def side_fix?(x, y, d)
    passable_tile?(x, y, d) && character_collision?(x, y, d)
  end
  #--------------------------------------------------------------------------
  # * New method: fix_move_straight
  #--------------------------------------------------------------------------
  def fix_move_straight(d)
    return if moving?
    @x = $game_map.round_x_with_direction(@x, d)
    @y = $game_map.round_y_with_direction(@y, d)
    follower_control_move_update(d, d)
    add_next_movement(d)
    increase_steps
    @moved = player?
  end
  #--------------------------------------------------------------------------
  # * New method: add_next_movement
  #--------------------------------------------------------------------------
  def add_next_movement(d)
    return unless follower? || player?
    return if $imported[:ve_followers_control]# && follower_control_block
    @next_movement.push(d)
  end
  #--------------------------------------------------------------------------
  # * New method: follower_control_block
  #--------------------------------------------------------------------------
  def follower_control_block
    return true if follower? && origin_position
    return true if $game_player.followers.gathering_origin?
    return false
  end
  #--------------------------------------------------------------------------
  # * New method: front_collision?
  #--------------------------------------------------------------------------
  def front_collision?(x, y, d)
    return false if (@diagonal && @diagonal != 0) || @diagonal_move
    result = !front_collision_horiz(x, y, d) if (d == 2 || d == 8)
    result = !front_collision_vert(x, y, d)  if (d == 4 || d == 6)
    result
  end
  #--------------------------------------------------------------------------
  # * New method: front_collision_horiz
  #--------------------------------------------------------------------------
  def front_collision_horiz(x, y, d)
    side_collision_fix?(x, y, d, 4, 4) || side_collision_fix?(x, y, d, 6, 4)
  end
  #--------------------------------------------------------------------------
  # * New method: front_collision_vert
  #--------------------------------------------------------------------------
  def front_collision_vert(x, y, d)
    side_collision_fix?(x, y, d, 2, 4) || side_collision_fix?(x, y, d, 8, 4)
  end
  #--------------------------------------------------------------------------
  # * New method: step_over?
  #--------------------------------------------------------------------------
  def step_over?
    @through
  end
  #--------------------------------------------------------------------------
  # * New method: bw
  #--------------------------------------------------------------------------
  def bw
    setup_bitmap_dimension unless @bw && character_name == @character_name_wh
    @bw
  end
  #--------------------------------------------------------------------------
  # * New method: bh
  #--------------------------------------------------------------------------
  def bh
    setup_bitmap_dimension unless @bh && character_name == @character_name_wh
    @bh
  end
  #--------------------------------------------------------------------------
  # * New method: setup_bitmap_dimension
  #--------------------------------------------------------------------------
  def setup_bitmap_dimension
    @character_name_wh = character_name
    bitmap = Cache.character(character_name).clone
    sign = @character_name[/^[\!\$]./]
    if character_name != "" && @tile_id == 0 && sign && sign.include?('$')
      @bw = bitmap.width  / 32.0 / frames
      @bh = bitmap.height / 32.0 / 4
    elsif character_name != "" && @tile_id == 0
      @bw = bitmap.width  / 32.0 / (frames * 4)
      @bh = bitmap.height / 32.0 / 8
    else
      @bw = 1.0
      @bh = 1.0
    end
    bitmap.dispose
  end
  #--------------------------------------------------------------------------
  # * New method: collision?
  #--------------------------------------------------------------------------
  def collision?(x, y, w, h)
    ax1, ay1, ax2, ay2 = setup_rect(x, y, w, h)
    bx1, by1, bx2, by2 = setup_rect(@x, @y, bw, bh)
    ax2 > bx1 && ax1 < bx2 && ay2 > by1 && ay1 < by2
  end
  #--------------------------------------------------------------------------
  # * New method: over?
  #--------------------------------------------------------------------------
  def over?(x, y)
    ax1, ay1, ax2, ay2 = setup_rect(x, y - 0.125, 0, 0)
    bx1, by1, bx2, by2 = setup_rect(@real_x, @real_y, bw, bh - 0.125)
    ax2 >= bx1 && ax1 <= bx2 && ay2 >= by1 && ay1 <= by2
  end
  #--------------------------------------------------------------------------
  # * New method: setup_rect
  #--------------------------------------------------------------------------
  def setup_rect(x, y, w, h)
    x1 = x - w / 2.0
    y1 = y - h
    x2 = x1 + w
    y2 = y1 + h
    [x1, y1, x2, y2]
  end
  #--------------------------------------------------------------------------
  # * New method: align_with
  #--------------------------------------------------------------------------
  def align_with(x, y)
    d  = @direction
    @x = $game_map.round_x_with_direction(x, 0) if d == 2 || d == 8
    @y = $game_map.round_y_with_direction(y, 0) if d == 6 || d == 4
    dx = (d == 2 || d == 8) ? (@x - @real_x) / 0.125 : 0
    dy = (d == 4 || d == 6) ? (@y - @real_y) / 0.125 : 0
    set_direction(dx > 0 ? 6 : dx < 0 ? 4 : dy > 0 ? 2 : dy < 0 ? 8 : d)
    @real_x = $game_map.x_with_direction(@x, reverse_dir(@direction), dx.abs)
    @real_y = $game_map.y_with_direction(@y, reverse_dir(@direction), dy.abs)
    update_for_align while moving?
    @direction = d
  end
  #--------------------------------------------------------------------------
  # * New method: update_for_align
  #--------------------------------------------------------------------------
  def update_for_align
    SceneManager.scene.update_basic
    SceneManager.scene.spriteset.update
    $game_map.update(true)
    $game_timer.update
    update_animation
    update_move
  end
  #--------------------------------------------------------------------------
  # * New method: fix_position
  #--------------------------------------------------------------------------
  def fix_position(n)
    (n * 64 / 8).round / 8.0
  end
end

#==============================================================================
# ** Game_Player
#------------------------------------------------------------------------------
#  This class handles maps. It includes event starting determinants and map
# scrolling functions. The instance of this class is referenced by $game_map.
#==============================================================================

class Game_Player < Game_Character
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :over_event
  attr_accessor :land_test
  #--------------------------------------------------------------------------
  # * Overwrite method: check_event_trigger_there
  #--------------------------------------------------------------------------
  def check_event_trigger_there(triggers)
    x2 = $game_map.round_x_with_direction(@x, @direction)
    y2 = $game_map.round_y_with_direction(@y, @direction)
    start_map_event(x2, y2, triggers, true)
    return if $game_map.any_event_starting?
    return unless counter_tile?
    x3 = $game_map.check_x_with_direction(x2, @direction)
    y3 = $game_map.check_y_with_direction(y2, @direction)
    start_map_event(x3, y3, triggers, true)
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: start_map_event
  #--------------------------------------------------------------------------
  def start_map_event(x, y, triggers, normal)
    return if $game_map.interpreter.running?
    $game_map.events_xy(x, y).each do |event|
      event.start if check_event_contiontion(x, y, event, triggers, normal)
    end
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: update_nonmoving
  #--------------------------------------------------------------------------
  def update_nonmoving(last_moving)
    return if $game_map.interpreter.running?
    moved  = @moved
    @moved = false
    if last_moving || moved
      $game_party.on_player_walk
      return if check_touch_event
    end
    if movable? && Input.trigger?(:C)
      return if get_on_off_vehicle
      return if check_action_event
    end
    @over_event -= 1 if @over_event > 0 && (last_moving || moved)
    update_encounter if last_moving || moved
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: get_on_vehicle
  #--------------------------------------------------------------------------
  def get_on_vehicle
    setup_vehicle
    enter_vehicle if vehicle
    @vehicle_getting_on
  end
  #--------------------------------------------------------------------------
  # * Overwrite method: increase_steps
  #--------------------------------------------------------------------------
  def increase_steps
    super
    if normal_walk?
      @steps += 1
      $game_player.damage_floor  = 0 unless on_damage_floor?
      $game_player.damage_floor += 1
      $game_party.increase_steps if @steps % 8 == 0
    end
  end
  #--------------------------------------------------------------------------
  # * Alias method: clear_transfer_info
  #--------------------------------------------------------------------------
  alias :clear_transfer_info_ve_pixel_movement :clear_transfer_info
  def clear_transfer_info
    clear_transfer_info_ve_pixel_movement
    clear_next_movement
  end
  #--------------------------------------------------------------------------
  # * Alias method: update
  #--------------------------------------------------------------------------
  alias :update_ve_gp_pixel_movement :update
  def update
    @followers.move unless $imported[:ve_followers_options]
    update_ve_gp_pixel_movement
  end
  #--------------------------------------------------------------------------
  # * Alias method: move_by_input
  #--------------------------------------------------------------------------
  alias :move_by_input_ve_gp_pixel_movement :move_by_input
  def move_by_input
    return unless @move_list.empty?
    move_by_input_ve_gp_pixel_movement
  end
  #--------------------------------------------------------------------------
  # * Alias method: move_by_input
  #--------------------------------------------------------------------------
  alias :update_vehicle_get_on_ve_gp_pixel_movement :update_vehicle_get_on
  def update_vehicle_get_on
    return unless @move_list.empty?
    @followers.gather   unless @followers.gathered?
    @through = false    if @followers.gathered?
    clear_next_movement if @followers.gathered?
    update_vehicle_get_on_ve_gp_pixel_movement if @followers.gathered?
  end
  #--------------------------------------------------------------------------
  # * Alias method: update_vehicle_get_off
  #--------------------------------------------------------------------------
  alias :update_vehicle_get_off_ve_gp_pixel_movement :update_vehicle_get_off
  def update_vehicle_get_off
    return unless @move_list.empty?
    @followers.gather   unless @followers.gathered?
    clear_next_movement if @followers.gathered?
    @through = false    if !@followers.gathering? && vehicle.altitude == 0
    update_vehicle_get_off_ve_gp_pixel_movement if @followers.gathered?
  end
  #--------------------------------------------------------------------------
  # * Alias method: get_off_vehicle
  #--------------------------------------------------------------------------
  alias :get_off_vehicle_ve_gp_pixel_movement :get_off_vehicle
  def get_off_vehicle
    result = get_off_vehicle_ve_gp_pixel_movement
    clear_vehicle_off if result
    result
  end
  #--------------------------------------------------------------------------
  # * New method: clear_vehicle_off
  #--------------------------------------------------------------------------
  def clear_vehicle_off
    @through = true
    clear_next_movement
    @followers.synchronize(@x, @y, @direction)
  end
  #--------------------------------------------------------------------------
  # * New method: check_event_contiontion
  #--------------------------------------------------------------------------
  def check_event_contiontion(x, y, event, triggers, normal)
    passable = passable_tile?(@x, @y, @direction)
    w = (counter_tile? || !passable) ? 1.0 : bw
    h = (counter_tile? || !passable) ? 1.0 : bh
    return false unless event.trigger_in?(triggers)
    return false unless event.event_priority?(normal)
    return false unless passable || event.over_tile? || counter_tile?
    return false unless event.collision?(x, y, w, h) || !jumping?
    return false unless !event.in_front? || front_collision?(x, y, @direction)
    return true
  end
  #--------------------------------------------------------------------------
  # * New method: counter_tile?
  #--------------------------------------------------------------------------
  def counter_tile?
    x = $game_map.check_x_with_direction(@x, @direction)
    y = $game_map.check_y_with_direction(@y, @direction)
    $game_map.counter?(x, y)
  end
  #--------------------------------------------------------------------------
  # * New method: setup_vehicle
  #--------------------------------------------------------------------------
  def setup_vehicle
    $game_map.vehicles.compact.each do |vehicle|
      next unless vehicle.enter_vechicle?(@x, @y, @direction)
      @vehicle_type = vehicle.type
      break if vehicle
    end
  end
  #--------------------------------------------------------------------------
  # * New method: enter_vehicle
  #--------------------------------------------------------------------------
  def enter_vehicle
    align_with(vehicle.x, vehicle.y) unless in_airship?
    @vehicle_getting_on = true
    force_move_forward unless in_airship?
    @through = true
    @followers.gather
  end
  #--------------------------------------------------------------------------
  # * New method: clear_next_movement
  #--------------------------------------------------------------------------
  def clear_next_movement
    @next_movement.clear
    @followers.clear_move_list
    @followers.clear_next_movement
  end
  #--------------------------------------------------------------------------
  # * New method: step_times
  #--------------------------------------------------------------------------
  def step_times
    (move_route_forcing || not_driving?) ? super : 1
  end
  #--------------------------------------------------------------------------
  # * New method: not_driving?
  #--------------------------------------------------------------------------
  def not_driving?
    vehicle && !vehicle.driving
  end
  #--------------------------------------------------------------------------
  # * New method: move_straight
  #--------------------------------------------------------------------------
  def move_straight(d, turn_ok = true)
    super
  end
  #--------------------------------------------------------------------------
  # * New method: move_diagonal
  #--------------------------------------------------------------------------
  def move_diagonal(horz, vert)
    super
  end
  #--------------------------------------------------------------------------
  # * New method: setup_bitmap_dimension
  #--------------------------------------------------------------------------
  def setup_bitmap_dimension
    @bw = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
    @bh = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
  end
end

#==============================================================================
# ** Game_Follower
#------------------------------------------------------------------------------
#  This class handles the followers. Followers are the actors of the party
# that follows the leader in a line. It's used within the Game_Followers class.
#==============================================================================

class Game_Follower < Game_Character
  #--------------------------------------------------------------------------
  # * Overwrite method: chase_preceding_character
  #--------------------------------------------------------------------------
  def chase_preceding_character
    return if $imported[:ve_followers_control] && cant_follow_character
    return if $imported[:ve_followers_options]
    unless moving? || @move_list.size > 0
      move_size = @preceding_character.next_movement.size
      if move_size >= 8 || (move_size > 0 && gathering?)
        update_chasing
      elsif gathering? && !gathered?
        move_toward_player
        @move_list.clear if gathered?
      end
    end
  end
  #--------------------------------------------------------------------------
  # * New method: update_chasing
  #--------------------------------------------------------------------------
  def update_chasing
    next_move = @preceding_character.next_movement.shift
    move_straight(next_move)  if next_move.numeric?
    move_diagonal(*next_move) if next_move.array?
  end
  #--------------------------------------------------------------------------
  # * New method: gathered?
  #--------------------------------------------------------------------------
  def gathered?
    pos?($game_player.x, $game_player.y)
  end
  #--------------------------------------------------------------------------
  # * New method: move_straight
  #--------------------------------------------------------------------------
  def move_straight(d, turn_ok = true)
    super
  end
  #--------------------------------------------------------------------------
  # * New method: move_diagonal
  #--------------------------------------------------------------------------
  def move_diagonal(horz, vert)
    super
  end
  #--------------------------------------------------------------------------
  # * New method: movement_size
  #--------------------------------------------------------------------------
  def movement_size
    gathering? ? 0 : 8
  end
  #--------------------------------------------------------------------------
  # * New method: step_times
  #--------------------------------------------------------------------------
  def step_times
    move_route_forcing ? super : 1
  end
  #--------------------------------------------------------------------------
  # * New method: setup_bitmap_dimension
  #--------------------------------------------------------------------------
  def setup_bitmap_dimension
    @bw = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
    @bh = VE_PLAYER_BIG_COLLISION ? 1.0 : 0.75
  end
end

#==============================================================================
# ** Game_Followers
#------------------------------------------------------------------------------
#  This class handles the followers. It's a wrapper for the built-in class
# "Array." It's used within the Game_Player class.
#==============================================================================

class Game_Followers
  #--------------------------------------------------------------------------
  # * New method: clear_next_movement
  #--------------------------------------------------------------------------
  def clear_next_movement
    each {|follower| follower.next_movement.clear }
  end
  #--------------------------------------------------------------------------
  # * New method: clear_move_list
  #--------------------------------------------------------------------------
  def clear_move_list
    each {|follower| follower.move_list.clear }
  end
  #--------------------------------------------------------------------------
  # * New method: gathered?
  #--------------------------------------------------------------------------
  def gathered?
    @data.all? {|follower| follower.gathered? }
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  This class deals with events. It handles functions including event page
# switching via condition determinants, and running parallel process events.
# It's used within the Game_Map class.
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # * Overwrite method: collide_with_player_characters?
  #--------------------------------------------------------------------------
  def collide_with_player_characters?(x, y)
    normal_priority? && player_collision?(x, y)
  end
  #--------------------------------------------------------------------------
  # * Alias method: start
  #--------------------------------------------------------------------------
  alias :start_ve_pixel_movement :start
  def start
    start_ve_pixel_movement
    $game_player.over_event = 8 if step_over? && !step_trigger?
  end
  #--------------------------------------------------------------------------
  # * Alias method: setup_page_settings
  #--------------------------------------------------------------------------
  alias :setup_page_settings_ve_pixel_movement :setup_page_settings
  def setup_page_settings
    setup_page_settings_ve_pixel_movement
    @move_steps   = note =~ /<MOVE STEPS: (\d+)>/i ? $1.to_i : nil
    @step_trigger = note =~ /<EACH STEP TRIGGER>/i ? true : false
    @in_front     = note =~ /<FRONT COLLISION>/i   ? true : false
    @over_tile    = note =~ /<OVER TILE>/i         ? true : false
    @side_fix     = note =~ /<NO SIDE COLLISION FIX>/i ? false : true
  end
  #--------------------------------------------------------------------------
  # * New method: player_collision?
  #--------------------------------------------------------------------------
  def player_collision?(x, y)
    $game_map.actors.any? {|actor| actor.collision?(x, y, bh, bw)}
  end 
  #--------------------------------------------------------------------------
  # * New method: event_priority?
  #--------------------------------------------------------------------------
  def event_priority?(normal)
    (normal_priority? == normal || (@through && !normal)) &&
    (normal_priority? || @trigger == 0 || $game_player.over_event == 0)
  end
  #--------------------------------------------------------------------------
  # * New method: check_event_trigger_touch
  #--------------------------------------------------------------------------
  def check_event_trigger_touch(x, y)
    return if $game_map.interpreter.running?
    if @trigger == 2 && $game_player.collision?(x, y, bh, bw)
      start if !jumping? && normal_priority?
    end
  end
  #--------------------------------------------------------------------------
  # * New method: step_over?
  #--------------------------------------------------------------------------
  def step_over?
    super || (@character_name == "" && @tile_id == 0) || @priority_type == 0
  end
  #--------------------------------------------------------------------------
  # * New method: step_times
  #--------------------------------------------------------------------------
  def step_times
    @move_steps ? @move_steps : super
  end
  #--------------------------------------------------------------------------
  # * New method: step_trigger?
  #--------------------------------------------------------------------------
  def step_trigger?
    @step_trigger
  end
  #--------------------------------------------------------------------------
  # * New method: in_front?
  #--------------------------------------------------------------------------
  def in_front?
    @in_front
  end
  #--------------------------------------------------------------------------
  # * New method: over_tile?
  #--------------------------------------------------------------------------
  def over_tile?
    @over_tile
  end
  #--------------------------------------------------------------------------
  # * New method: side_collision?
  #--------------------------------------------------------------------------
  def side_collision?
    @side_fix
  end
  #--------------------------------------------------------------------------
  # * New method: setup_bitmap_dimension
  #--------------------------------------------------------------------------
  def setup_bitmap_dimension
    regexp = /<EVENT SIZE: (\d+), (\d+)>/i
    note   =~ regexp ? setup_custom_dimension($1.to_i, $2.to_i) : super
  end
  #--------------------------------------------------------------------------
  # * New method: setup_custom_dimension
  #--------------------------------------------------------------------------
  def setup_custom_dimension(x, y)
    x1 = (x / 8).to_i
    y1 = (y / 8).to_i
    @bw = x1 / 4.0
    @bh = y1 / 4.0
  end
end

#==============================================================================
# ** Game_Vehicle
#------------------------------------------------------------------------------
#  This class handles vehicles. It's used within the Game_Map class. If there
# are no vehicles on the current map, the coordinates is set to (-1,-1).
#==============================================================================

class Game_Vehicle < Game_Character
  #--------------------------------------------------------------------------
  # * Overwrite method: land_ok?
  #--------------------------------------------------------------------------
  def land_ok?(x, y, d)
    @type == :airship ? airship_landable?(x, y) : check_landable?(x, y, d)
  end
  #--------------------------------------------------------------------------
  # * New method: land_test
  #--------------------------------------------------------------------------
  def land_test
    @land_test
  end
  #--------------------------------------------------------------------------
  # * New method: step_over?
  #--------------------------------------------------------------------------
  def step_over?
    above? || super
  end
  #--------------------------------------------------------------------------
  # * New method: check_landable?
  #--------------------------------------------------------------------------
  def check_landable?(x, y, d)
    x2 = $game_map.check_x_with_direction(x, d)
    y2 = $game_map.check_y_with_direction(y, d)
    @land_test = true
    result = passable?(x2, y2, d)
    @land_test = false
    result
  end
  #--------------------------------------------------------------------------
  # * New method: airship_landable?
  #--------------------------------------------------------------------------
  def airship_landable?(x, y)
    [2, 4, 6, 8].any? {|d| passable?(x, y, d) }
  end
  #--------------------------------------------------------------------------
  # * New method: passable_normal?
  #--------------------------------------------------------------------------
  def passable_normal?(x, y, d ,d2, ceil = false)
    @land_test ? landable_normal?(x, y, d ,d2, ceil) : super(x, y, d ,d2, ceil)
  end
  #--------------------------------------------------------------------------
  # * New method: landable_normal?
  #--------------------------------------------------------------------------
  def landable_normal?(x, y, d ,d2, ceil)
    x1 = $game_map.round_x(x)
    y1 = $game_map.round_y(y)
    return false unless $game_map.valid?(x1, y1)
    return true if @through || debug_through?
    return false unless map_passable?(x1, y1, d)
    return false unless map_passable?(x1, y1, d2) || !ceil
    return false unless map_passable?(x1, y1, reverse_dir(d))
    return true
  end
  #--------------------------------------------------------------------------
  # * New method: enter_vechicle?
  #--------------------------------------------------------------------------
  def enter_vechicle?(x, y, d)
    return false if @map_id != $game_map.map_id
    x2 = $game_map.round_x_with_direction(x, d)
    y2 = $game_map.round_y_with_direction(y, d)
    x3 = $game_map.check_x_with_direction(@x, reverse_dir(d))
    y3 = $game_map.check_y_with_direction(@y, reverse_dir(d))
    ( above? && collision?(x, y - 0.125, bw * 0.75, bh * 0.75)) ||
    (!above? && collision?(x2, y2, bw, bh) && map_passable?(x3, y3, d))
  end
  #--------------------------------------------------------------------------
  # * New method: collision_condition?
  #--------------------------------------------------------------------------
  def collision_condition?(x, y, bw, bh, player)
    return false if step_over?
    return false if player.player? && self == player.vehicle
    return false if !collision?(x, y, bw, bh)
    return true
  end
end
 

Morpheus

Jack-of-Trades
Veteran
Joined
Mar 14, 2012
Messages
139
Reaction score
13
First Language
english
Primarily Uses
N/A
here fix the problem a bit, when the character collides with an event, the movement path is no longer repeated until the player goes out of his way, however (I am not very expert in code)
Now the movement route respects the pixels because I have deactivated the "step_times" method that when placing a movement route page is multiplying them by 8, But not now. therefore more actions in the move route would be needed for the event to move in 32 pixels.

the modification I made was to replace the "move straight" and "move_diagonal" method with that of RPG Maker
I hope it is some help for you.
Appreciate the effort, but now not only are all events 32 pixels again, but followers don't follow you anymore as well. Also the whole needing ALOT more "set movement" commands kinda ruins it.
 

mylafter

I’m a creep... I’m a weirdo...
Veteran
Joined
Dec 30, 2012
Messages
185
Reaction score
113
First Language
English
Primarily Uses
N/A
here fix the problem a bit, when the character collides with an event, the movement path is no longer repeated until the player goes out of his way, however (I am not very expert in code)
Now the movement route respects the pixels because I have deactivated the "step_times" method that when placing a movement route page is multiplying them by 8, But not now. therefore more actions in the move route would be needed for the event to move in 32 pixels.

the modification I made was to replace the "move straight" and "move_diagonal" method with that of RPG Maker
I hope it is some help for you.
You definitely fixed the issue. I don't mind having to add extra move routes for it to work but it would be nice if we could possibly find a way to fix it.

And according to Morpheus followers don't follow anymore? I'm not using followers for my project so it's fine, but it probably be best to find a way to also fix that.
 

Users Who Are Viewing This Thread (Users: 0, Guests: 1)

Latest Threads

Latest Posts

Latest Profile Posts

Making it a rule that I don't do any world building for my new game before the actual gameplay is concrete and working. I have 16 years of lore to work with anyway.
Cheesy power metal makes everything better. No matter what you do, you'll feel heroic doing it.
Starting to really like the first of my madness areas. I think the eyes looking at them really helps to sell the place. :LZSexcite:
Made idle animation for character. It first had only three frames but looked too different from walking animation and I had to draw five more.
MV and VX Ace both have good qualities.

Forum statistics

Threads
95,694
Messages
931,075
Members
126,032
Latest member
MadAtticGames
Top