[RMXP] NoMethodError error when using a pathfind script

NardBruh

Villager
Member
Joined
Jun 2, 2021
Messages
17
Reaction score
1
First Language
Portuguese
Primarily Uses
Other
Hello!

I'm a developer wanna-be currently working on a Ao Oni fangame, and currently, I'm trying to make a pathfinder script work for the chases, but so far, I've only been greeted with a error message:

43ffe6186a3ba396284f19985e74e4b0.png
I'm not the best at scripting, so I need help in order to figure out how to fix this.

The line that I wrote for the event is simple:

pathfind($game_player.x, $game_player.y)

And here's the script I'm trying to work with:

#=begin
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
# Advanced Pathfinding
# Author: ForeverZer0, mad.array
# Version: 1.0
# Date: 10.12.2011
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
#
# Introduction:
# This is an advanced an highly inteligent pathfinding system. It allows for
# the user to either through script or script call quickly and easily have
# events or the game player automatically walk a path to a given set of
# coordinates. The system is smart enough to quickly find paths through
# relatively complex areas, and asjust on the fly for any obstacle that moves
# to block its path. I used the A* algorithm, basic search algorithm used
# often for robotics. More on this algorithm can be read about here:
#
# http://en.wikipedia.org/wiki/A*_search_algorithm
#
# Features:
# - Fast and intelligent pathfinding
# - Easy to use script calls
# - Optional "range" parameter can have character find alternate locations
# if the preferred one is blocked and they are within the given range.
# - Optional callbacks can be given to have something execute if when the
# character reaches its goal, or when it fails to do so.
#
# Instructions:
# - Place script below default scripts, and above "Main".
# - Use the following script call:
#
# pathfind(X, Y, CHARACTER, RANGE, SUCCESS_PROC, FAIL_PROC)
#
# The X and Y are the only required arguments. The others can be omitted.
#
# X - The x-coordinate to pathfind to. If X is a string or array then
# strings must be contained within "quotation marks" and the array
# within [square brackets].
# Y - The y-coordinate to pathfind to. If using a string or array, DO NOT
# leave Y blank. It will cause the script to crash.
#
# CHARACTER - Either an instance of the character ($game_player,
# $game_map.events[ID], etc) or the ID of a character. The ID
# will be the event ID. Use -1 for the game player.
#
# SUCCESS_PROC - A Proc object that will be executed when the player
# reaches the defined coordinates.
# FAILURE_PROC - A Proc object that will be executed when the player
# cannot reach the defined coordinates.
#
# - As default, the pathfinder will make 35 attempts to recalculate a route
# that gets blocked. This value can be changed in game with the script
# call:
# $game_map.collision_retry = NUMBER
#
# You can change the default value if desired by looking down to the first
# class below in the main script.
# - For longer pathfind routes, it is sometimes necessary to reset the
# search limiter. This may cause increased lag when an object blocks the
# character from being able to move, but will increase the range that the
# system can work with. Use the following script call:
#
# $game_map.search_limiter = NUMBER (Default 1000)
#
# - If you are experiencing any compatibility problems, go to the Game_Map
# class below and set @recalculate_paths to false. This will take away some
# of the efficiency of recalculating collisions, but will improve may fix
# your problem.
#
# Compatibility:
# Highly compatible. May experience issues with Custom Movement scripts,
# but even then, it is unlikely.
#
# Credits/Thanks:
# - ForeverZer0, for the script
# - Special thanks to Jragyn for help making the big maze for the demo and
# help testing.
# - Credit goes to the Peter Hart, Nils Nilsson and Bertram Raphael for the
# original search algorithm that was implemented
#
#+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+

#===============================================================================
# ** Game_Map
#===============================================================================

class Game_Map

attr_accessor :collision_retry
attr_accessor :recalculate_paths
attr_accessor :search_limiter

alias zer0_pathfinding_init initialize
def initialize
# Initialize instance variables used for pathfinding.
@collision_retry = 35
@recalculate_paths = true
@search_limiter = 1000
# Original method
zer0_pathfinding_init
end
end

#===============================================================================
# ** Interpreter
#===============================================================================

class Interpreter

def pathfind(x, y, *args)
@x = x
@y = y
args[0] = @event_id if args[0] == nil
args[1] = 0 if args[1] == nil
if @x.is_a?(Array)
decidepath(@x, @y, @args)
end
findpathevent(@x,@y, args)
Pathfind.new(Node.new(@x, @y), *args)
end

def decidepath(x, y, args)
r = rand(100) + 1
for i in 0...x.size
targ1 = 1 + (100/x.size) * i
targ2 = (100/x.size) * (i +1)
if r >= targ1 && r <=targ2
@x=x
end
end
end

def findpathevent(x, y, args)
xs = []
ys = []
proxx = []
proxy = []
distance = []
chosen = nil
if x.is_a?(String)
for event in $game_map.events.values
if event.name == x
xs.push(event.x)
ys.push(event.y)
end
end
if args[0] > 0
runnerx = $game_map.events[args[0]].x
runnery = $game_map.events[args[0]].y
else
runnerx = $game_player.x
runnery = $game_player.y
end
if xs.size > 1
for i in 0...xs.size# - 1
proxx = runnerx - xs
proxy = runnery - ys
proxx *= -1 if proxx <0
proxy *= -1 if proxy <0
if proxx > proxy
distance = proxx - proxy
elsif proxx < proxy
distance = proxy - proxx
elsif proxx==0
distance = proxy
elsif proxy==0 || proxy == proxx
distance = proxx
end
end
j = 0
while chosen == nil
chosen = distance.index(j)
j+=1
end
@x = xs[chosen]
@y = ys[chosen]
else
@x = xs[0]
@y = ys[0]
end
end
end
end


class Game_Event

def name
return @event.name
end
end

#==============================================================================
# ** Pathfind
#==============================================================================

class Pathfind

attr_reader :route
attr_accessor :range
attr_reader :goal
attr_reader :found
attr_reader :character
attr_accessor :success_proc
attr_accessor :failure_proc
attr_accessor :target
attr_accessor :collisions

def initialize(node, char = -1, range = 0, *callbacks)
# Set the character. Can either us an ID or an instance of a Game_Character.
# A value of -1, which is default, is the Game_Player.
if char.is_a?(Integer)
@character = (char == -1) ? $game_player : $game_map.events[char]
elsif char.is_a?(Game_Character)
@character = char
end
# Set forcing flag. Will be disabled for recalculating on the fly.
@forcing = true
# Call a public method, since this method may need to be used again,
# and "initialize" is private.
setup(node, range, *callbacks)
end


def setup(node, range = 0, *callbacks)
# Initialize the node we are trying to get to.
@target = Node.new(node.x, node.y)
@goal = @target.clone
# Set beginning nodes and required variables.
@start_node = Node.new(@character.x, @character.y)
@nearest = Node.new(0, 0, 0, -1)
@range, @Found, @collisions = range, false, 0
# Set callbacks for success and failure if included, else nil.
@success_proc = callbacks[0]
@failure_proc= callbacks[1]
# Initialize sets to track open and closed nodes
@open_set, @close_set = [@start_node], {}
# Find the optimal path
calculate_path
end

def calculate_path
# Only do calculation if goal is actually passable, unless we only
# need to get close or within range
if @character.passable?(@goal.x, @goal.y, 0) || @range > 0
# Initialize counter
counter, wait = 0, 0
until @open_set.empty?

counter += 1
# Give up if pathfinding is taking more than 500 iterations
if counter >= $game_map.search_limiter
@Found = false
break
end
# Get the node with lowest cost and add it to the closed list
@current_node = get_current
@close_set[[@current_node.x, @current_node.y]] = @current_node
if @current_node == @goal ||
(@range > 0 && @goal.in_range?(@current_node, @range) &&
!@character.passable?(@goal.x, @goal.y,0))
# We reached goal, exit the loop!
@target = @goal
@goal, @Found = @current_node, true
break
else # if not goal
# Keep track of the node with the lowest cost so far
if @current_node.heuristic < @nearest.heuristic ||
@nearest.heuristic < 1
@nearest = @current_node
end
# Get adjacent nodes and check if they can be added to the open list
neighbor_nodes(@current_node).each {|neighbor|
# Skip Node if it already exists in one of the lists.
next if can_skip?(neighbor)
# Add node to open list following the binary heap conventions
@open_set.push(neighbor)
arrange(@open_set.size - 1)
}
end
end
end
# If no path was found, see if we can get close to goal
unless @Found
if @range > 0 && @nearest.heuristic > 0
# Create an alternate path.
setup(@nearest, @range, @success_proc, @failure_proc)
elsif @failure_proc != nil && (($game_map.collision_retry == 0) ||
(@collisions > $game_map.collision_retry))
# If out of retries, call the Proc for failure if defined
@failure_proc.call
end
end
# Create the move route using the generated path
create_move_route
end

def create_move_route
# There's no path to generate if no path was found
return if !@found
# Create a new move route that isn't repeatable
@route = RPG::MoveRoute.new
@route.repeat = false
# Generate path by starting from goal and following parents
node = @goal
while node.parent
# Get direction from parent to node as RPG::MoveCommand
code = case direction(node.parent.x, node.parent.y, node.x, node.y)
when 2 then 4 # Up
when 4 then 3 # Left
when 6 then 2 # Right
when 8 then 1 # Down
else; 0
end
# Add movement code to the start of the array
@route.list.unshift(RPG::MoveCommand.new(code)) if code != 0
node = node.parent
end
# If the path should be assigned to the character
if (@forcing && !@route.list.empty?)
@collisions = 0
@character.paths.push(self)
@character.force_move_route(@route) if @character.paths.size == 1
end
# Reset forcing flag if needed
@forcing = true
# Return the constructed RPG::MoveRoute
return @route
end

def arrange(index)
# Rearrange nodes in the open_set
while index > 0
# Break loop unless current item's cost is less than parent's
break if @open_set[index].score > @open_set[index / 2].score
# Bring lowest value to the top.
temp = @open_set[index / 2]
@open_set[index / 2] = @open_set[index]
@open_set[index] = temp
index /= 2
end
end

def get_current
return if @open_set.empty?
return @open_set[0] if @open_set.size == 1
# Set current node to local variable and replace it with the last
current = @open_set[0]
@open_set[0] = @open_set.pop
# Loop and rearrange array according to the A* algorithm until done.
y = 0
loop {
x = y
# If two children exist
if 2 * x + 1 < @open_set.size
if @open_set[2 * x].score <= @open_set[x].score
y = 2 * x
if @open_set[2 * x + 1].score <= @open_set[y].score
y = 2 * x + 1
end
end
# If only one child exists
elsif 2 * x < @open_set.size &&
@open_set[2 * x].score <= @open_set[x].score
y = 2 * x
end
# Swap a child if it is less than the parent.
break if x == y
temp = @open_set[x]
@open_set[x] = @open_set[y]
@open_set[y] = temp
}
# Return the original first node (which was removed)
return current
end

def direction(x1, y1, x2, y2)
# Return the numerical direction between coordinates.
return 6 if x1 > x2 # Right
return 4 if x1 < x2 # Left
return 2 if y1 > y2 # Bottom
return 8 if y1 < y2 # Top
return 0
end

def neighbor_nodes(node)
# Create array to hold the nodes, then check each direction.
nodes = []
nodes.push(get_neighbor(node.x + 1, node.y, node)) # Right
nodes.push(get_neighbor(node.x - 1, node.y, node)) # Left
nodes.push(get_neighbor(node.x, node.y + 1, node)) # Down
nodes.push(get_neighbor(node.x, node.y - 1, node)) # Up
# Remove any nil elements, then return results.
return nodes.compact
end

def get_neighbor(x, y, parent)
# Calculate direction, return new node if passable.
direction = direction(x, y, parent.x, parent.y)
if @character.passable?(parent.x, parent.y, direction)
# The heuristic is simply the distance
heuristics = ((x - @goal.x).abs + (y - @goal.y).abs)
return Node.new(x, y, parent, parent.cost + 1, heuristics)
end
end

def can_skip?(node)
# Branch by if node is in either the open or closed set.
if @open_set.include?(node)
index = @open_set.index(node)
return true if @open_set[index].score <= node.score
# Swap them and update list order
@open_set[index] = node
arrange(index)
return true
elsif @close_set[[node.x, node.y]] != nil
# If the existing passed node has a lower score than this one.
return true if @close_set[[node.x, node.y]].score <= node.score
# Update the existing node
@close_set[[node.x, node.y]] = node
end
# Return false if no criteria was met.
return false
end
end

#==============================================================================
# ** Game_Character
#==============================================================================

class Game_Character

attr_accessor :paths
attr_accessor :move_route_forcing
attr_accessor :move_route

alias zer0_pathfinding_init initialize
def initialize
# Add public instance variable for paths
@paths = []
# Original method
zer0_pathfinding_init
end

def next_route
# Stop any custom move route that may be occuring.
if @move_route != nil
# Set index and disable forcing of current route
@move_route_index = @move_route.list.size
@move_route_forcing = false
# Reset to what it was originally
@move_route = @original_move_route
@move_route_index = @original_move_route_index
@original_move_route = nil
end
# Remove first path from the paths array.
@paths.shift
# If there is another path to follow...
if @paths[0] != nil
# Setup path again to reflect any changes since original creation
@forcing = false
@paths[0].setup(@paths[0].target, @paths[0].range,
@paths[0].success_proc, @paths[0].failure_proc)
force_move_route(@paths[0].route) if @paths[0].found
end
end

alias zer0_recalculate_paths_move move_type_custom
def move_type_custom
if $game_map.recalculate_paths
# Interrupt if not stopping
return if jumping? || moving?
# Loop until finally arriving at move command list
while @move_route_index < @move_route.list.size
# Get the move command at index
command = @move_route.list[@move_route_index]
# If command code is 0 (end of list)
if command.code == 0
# If [repeat action] option is ON
if @move_route.repeat
# Reset move route index to the top of the list
@move_route_index = 0
end
# If [repeat action] option is OFF
unless @move_route.repeat
# If move route is forced and not repeating
if @move_route_forcing and not @move_route.repeat
# The move route is no longer forced (moving ended)
@move_route_forcing = false
# Restore original move route
@move_route = @original_move_route
@move_route_index = @original_move_route_index
@original_move_route = nil
# If there was a path to follow and we reached goal
if @paths[0] != nil
if self.x == @paths[0].goal.x &&
y == @paths[0].goal.y && @paths[0].success_proc
# Call success Proc if goal is reached and it is defined.
@paths[0].success_proc.call
end
next_route
end
end
# Clear stop count
@stop_count = 0
end
return
end # if command.code == 0
# For move commands (from move down to jump)
if command.code <= 14
# Branch by command code
case command.code
when 1 then move_down # Move down
when 2 then move_left # Move left
when 3 then move_right # Move right
when 4 then move_up # Move up
when 5 then move_lower_left # Move lower left
when 6 then move_lower_right # Move lower right
when 7 then move_upper_left # Move upper left
when 8 then move_upper_right # Move upper right
when 9 then move_random # Move random
when 10 then move_toward_player # Move toward player
when 11 then move_away_from_player # Move away from player
when 12 then move_forward # Step forward
when 13 then move_backward # Step backward
when 14 then jump(command.parameters[0], command.parameters[1]) # Jump
end
# If movement failure occurs when "Ignore If Can't Move" is unchecked.
if !@move_route.skippable && !moving? && !jumping?
# If path is current and collision limit is not reached
if @paths[0] != nil &&
@paths[0].collisions < $game_map.collision_retry
# Setup path again to update starting location.
# original goal node is used because pathfinding changes
# the goal node to current node
goal, range = @paths[0].target, @paths[0].range
reach = @paths[0].success_proc
fail = @paths[0].failure_proc
counter = @paths[0].collisions + 1
# Find another path to goal
@paths[0] = Pathfind.new(goal, self, range, reach, fail)
@paths[0].collisions = counter
force_move_route(@paths[0].route) if @paths[0].found
# Wait a bit before starting to follow the new path
@wait_count = 6
return
elsif paths[0] != nil
# Call failure Proc if defined and set move index.
@move_route_index = @move_route.list.size
@paths[0].failure_proc.call if @paths[0].failure_proc != nil
next_route
end
# End method
return
end
# Advance index
@move_route_index += 1
return
end # if command.code <= 14
# If waiting
if command.code == 15
# Set wait count (from provided parameter)
@wait_count = command.parameters[0] * 2 - 1
@move_route_index += 1
return
end # if command.code == 15
# If direction change (turning) command
if command.code >= 16 and command.code <= 26
# Branch by command code
case command.code
when 16 then turn_down # Turn down
when 17 then turn_left # Turn left
when 18 then turn_right # Turn right
when 19 then turn_up # Turn up
when 20 then turn_right_90 # Turn 90° right
when 21 then turn_left_90 # Turn 90° left
when 22 then turn_180 # Turn 180°
when 23 then turn_right_or_left_90 # Turn 90° right or left
when 24 then turn_random # Turn at Random
when 25 then turn_toward_player # Turn toward player
when 26 then turn_away_from_player # Turn away from player
end
@move_route_index += 1
return
end
# If other command (commands that don't 'return')
if command.code >= 27
# Branch by command code
case command.code
when 27 # Switch ON
$game_switches[command.parameters[0]] = true
$game_map.need_refresh = true
when 28 # Switch OFF
$game_switches[command.parameters[0]] = false
$game_map.need_refresh = true
when 29 then @move_speed = command.parameters[0] # Change speed
when 30 then @move_frequency = command.parameters[0] # Change freq
when 31 then @walk_anime = true # Move ON
when 32 then @walk_anime = false # Move OFF
when 33 then @step_anime = true # Stop ON
when 34 then @step_anime = false # Stop OFF
when 35 then @direction_fix = true # Direction ON
when 36 then @direction_fix = false # Direction OFF
when 37 then @through = true # Through ON
when 38 then @through = false # Through OFF
when 39 then @always_on_top = true # On top ON
when 40 then @always_on_top = false # On top OFF
when 41 # Change Graphic
# Can't change into a tile
@tile_id = 0
@character_name = command.parameters[0]
@character_hue = command.parameters[1]
# Update direction
if @original_direction != command.parameters[2]
@direction = command.parameters[2]
@original_direction = @direction
@prelock_direction = 0
end
# Update frame
if @original_pattern != command.parameters[3]
@Pattern = command.parameters[3]
@original_pattern = @Pattern
end
when 42 then @opacity = command.parameters[0] # Change Opacity
when 43 then @blend_type = command.parameters[0] # Change Blending
when 44 then $game_system.se_play(command.parameters[0]) # Play SE
when 45 then result = eval(command.parameters[0]) # Script
end
# Increment move index.
@move_route_index += 1
end
end
else
# Original method
zer0_recalculate_paths_move
end
end
end

#==============================================================================
# ** Node
#==============================================================================

class Node

attr_accessor :x
attr_accessor :y
attr_accessor :parent
attr_accessor :cost
attr_accessor :heuristic

def initialize(x, y, parent = nil, cost = 0, heuristic = 0)
# Set public instance variables.
@x, @y, @parent, @cost, @heuristic = x, y, parent, cost, heuristic
end

def score
# Return the current "score" of this node
return @cost + @heuristic
end

def in_range?(node, range)
# Return true/false if Nodes are within RANGE of each other.
return (@x - node.x).abs + (@y - node.y).abs <= range
end

def ==(node)
# Returns true/false of whether self and other are equal.
return ((node.is_a?(Node)) && (node.x == @x) && (node.y == @y))
end
end
#=end



Thanks in advance to whoever can help me out with this!
 

Andar

Veteran
Veteran
Joined
Mar 5, 2013
Messages
33,979
Reaction score
8,620
First Language
German
Primarily Uses
RMMV
have you started a new game after installing the script, or did you continue an old (and now propably incompatible) savefile?
 

NardBruh

Villager
Member
Joined
Jun 2, 2021
Messages
17
Reaction score
1
First Language
Portuguese
Primarily Uses
Other
have you started a new game after installing the script, or did you continue an old (and now propably incompatible) savefile?
I did actually, still results in that message
 

Shaz

Global Moderators
Global Mod
Joined
Mar 2, 2012
Messages
43,745
Reaction score
15,312
First Language
English
Primarily Uses
RMMV
I don't think you've given us the full script call. How did you do it - where did you put it?

Pathfind is a function of the interpreter, and you are trying to run it as a function of the event.

Are you putting pathfind(x, y) into a move route?
Are you putting $game_map.event[x].pathfind(...) as a script call?
Both are incorrect.

It looks like you simply put pathfind(x, y) as a script call into the event that you want to pathfind.
 

NardBruh

Villager
Member
Joined
Jun 2, 2021
Messages
17
Reaction score
1
First Language
Portuguese
Primarily Uses
Other
This is where I put it, inside the custom route of the event:
dd0bb95601c648d1e09143c55db6d937.png
I interpreted what you said as putting a script call in the event's command list, but it didn't work.

I also tried to make a parallel process event and common event, giving it the pathfinding command, but adding the character that it is supposed to affect, something like this:


pathfind(["Enemy"], $game_player.x, $game_player.y)

Both crashed the game too, so I'm not sure on what to do, currently.
 

Andar

Veteran
Veteran
Joined
Mar 5, 2013
Messages
33,979
Reaction score
8,620
First Language
German
Primarily Uses
RMMV
but adding the character that it is supposed to affect
you cannot add new data to script commands, they only work when used exactly as supposed.
in fact, your error is what happens whenever the script functions are used outside their supposed use.

This is the command that you are supposed to use:
# - Use the following script call:
#
# pathfind(X, Y, CHARACTER, RANGE, SUCCESS_PROC, FAIL_PROC)
So of course it will not work if you use it without the required information like
pathfind($game_player.x, $game_player.y)

You have to use the complete function if you want it to work.
Only the last three options are declared "optional" in the script description.
CHARACTER is not optional, so you have to use it, and exactly like it was described.

that means in third position, not in first like your own try above, and either as an ID or as an Object, not as an array of a single string.
 

NardBruh

Villager
Member
Joined
Jun 2, 2021
Messages
17
Reaction score
1
First Language
Portuguese
Primarily Uses
Other
In the script, it states that only x and y are neccessary, but after adding the $game_player to it, a different type of error occurs this time:
2cf8f87a152d35bb743404168c23a545.png
The line in specific being:

if @character.passable?(@goal.x, @goal.y, 0) || @range > 0

I guess range is neccessary after all, too, but I don't know how exactly I can set it up on the script.
 

Andar

Veteran
Veteran
Joined
Mar 5, 2013
Messages
33,979
Reaction score
8,620
First Language
German
Primarily Uses
RMMV
but after adding the $game_player to it
how did you add the player to it?
please give a screenshot of your input, and please the entire screenshot, not a cropped part as it is important when and where the command is executed.
I guess range is neccessary after all,
no, that guess is wrong - as proven by exactly the line you cited. || is short for OR, and the range is only considered if >0, so if there is no range (or range =0) that will not affect the command at all.
But it will affect the programming if you entered something as range that is not a range/number in your command, because that is one way how that error could be triggered - if you entered something in fourth data position that is not a valid range number.
 

NardBruh

Villager
Member
Joined
Jun 2, 2021
Messages
17
Reaction score
1
First Language
Portuguese
Primarily Uses
Other
The page of the event who's currently holding the script is this one, alongside the script itself:
646c26b74e761a08e6cff1937ebfa406.png
(The room instantly crashes when I enter it if I don't give the event a condition)

Here's the location of said event:
adf6e0e079bf17e43296f9ef799d0fe5.png
And before you ask why there's a ["Enemy"] in the line, it's basically for this (From the site that I found the script):
f2e6bf680d41ba79b0fc9453fc338a67.png
Is it possible that it is conflicting with the range?

(Note: I tried removing the []s, and it still crashes regardless)
 

Andar

Veteran
Veteran
Joined
Mar 5, 2013
Messages
33,979
Reaction score
8,620
First Language
German
Primarily Uses
RMMV
(Note: I tried removing the []s, and it still crashes regardless)
Of course it crashes, because the first argument of the function has to be a number and the X coordinate. You have to completely and totally erase the stupid ["Enemy"] that has absolutely nothing to do in the function!!!!

pathfind($game_player.x, $game_player.y, ID)

is the command you have to use, with ID being the event ID of the event that is to find the way toward the player.
In the case of the screenshot above, the ID of the event is 29


Because you should also have read the instructions about the Enemy name string more correctly:
the string REPLACES the x coordinate, which means that as soon as you use the name you can NEVER use $game_player.x in the same command.
It also means that using the target name (TARGET name), you can only send the event (that is still identified by the number in the third position) toward another event. It cannot be send toward the player that way.
So you can send event e toward the carrot event, you cannot move the carrot event by that method.
And as a result any use of that "enemy" will require you to give another event ID to be send toward that enemy, it will never move that enemy event.
 

NardBruh

Villager
Member
Joined
Jun 2, 2021
Messages
17
Reaction score
1
First Language
Portuguese
Primarily Uses
Other
OKAY OKAY, I got it to work!

I made a second event, set it to always set its position in consideration to the player's x and y (So basically it is always ontop of the player), here is how it looks:

pathfind("player position", $game_player.y, 3)

"player position" is the event, and the 3 is the enemy ID

I've never been this happy after seeing the Ao Oni not get stuck against any sort of surface, however, the game also ends up crashing at random, and directing me to this line of the code:


while @move_route_index < @move_route.list.size

I'm not sure why, I tried increasing the amount of attempts when it recalculates it, plus the limit of the search for collisions, yet it still crashed.

Notably, the crash only occurs when I do a merry-go-round on objects (Basically doing circles around solid objects while in a chase), so, I guess it's a problem related to that?
 

Latest Threads

Latest Posts

Latest Profile Posts

I'm so annoyed with myself...I can't get this code to work so it looks like I'm going the plugin route for a problem I should be able to do myself :kaolivid:Great. Now I get to murder save file compatibility. Again.
Can't believe my code from four years ago is still working! Did some expansions, and...
1635194553179.png
In related news, I may have an update for my old Extra status window plugin ready. That is, once I manage to sit down and update the documentation... and the demo project... :kaoswt:
How does one pronounce Godot? I've heard it pronounced a couple of different ways, and I genuinely don't know the proper way.
March 2020 ...
1635188823939.jpeg
... vs October 2021
You look like you had a rough day...Here, have a Baby Panda!

Forum statistics

Threads
116,077
Messages
1,095,555
Members
151,443
Latest member
Xtvback
Top