@ringozz/godot 0.1.0

package/gen/classes/AESContext.ts

@@ -0,0 +1,99 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * This class holds the context information required for encryption and decryption operations with AES (Advanced Encryption Standard). Both AES-ECB and AES-CBC modes are supported.
+ *
+ *
+ * ```gdscript
+ *
+ * extends Node
+ *
+ * var aes = AESContext.new()
+ *
+ * func _ready():
+ * 	var key = "My secret key!!!" # Key must be either 16 or 32 bytes.
+ * 	var data = "My secret text!!" # Data size must be multiple of 16 bytes, apply padding if needed.
+ * 	# Encrypt ECB
+ * 	aes.start(AESContext.MODE_ECB_ENCRYPT, key.to_utf8_buffer())
+ * 	var encrypted = aes.update(data.to_utf8_buffer())
+ * 	aes.finish()
+ * 	# Decrypt ECB
+ * 	aes.start(AESContext.MODE_ECB_DECRYPT, key.to_utf8_buffer())
+ * 	var decrypted = aes.update(encrypted)
+ * 	aes.finish()
+ * 	# Check ECB
+ * 	assert(decrypted == data.to_utf8_buffer())
+ *
+ * 	var iv = "My secret iv!!!!" # IV must be of exactly 16 bytes.
+ * 	# Encrypt CBC
+ * 	aes.start(AESContext.MODE_CBC_ENCRYPT, key.to_utf8_buffer(), iv.to_utf8_buffer())
+ * 	encrypted = aes.update(data.to_utf8_buffer())
+ * 	aes.finish()
+ * 	# Decrypt CBC
+ * 	aes.start(AESContext.MODE_CBC_DECRYPT, key.to_utf8_buffer(), iv.to_utf8_buffer())
+ * 	decrypted = aes.update(encrypted)
+ * 	aes.finish()
+ * 	# Check CBC
+ * 	assert(decrypted == data.to_utf8_buffer())
+ *
+ * ```
+ */
+export class AESContext extends RefCounted {
+    constructor(name = 41) { super(name); }
+
+    /**
+     * Start the AES context in the given `mode`. A `key` of either 16 or 32 bytes must always be provided, while an `iv` (initialization vector) of exactly 16 bytes, is only needed when `mode` is either {@link MODE_CBC_ENCRYPT} or {@link MODE_CBC_DECRYPT}.
+     */
+    start(mode: Mode, key: PackedByteArray, iv?: PackedByteArray /* = PackedByteArray() */): Error { return _C(this, 13829, mode, key, iv) as Error; }
+
+    /**
+     * Run the desired operation for this AES context. Will return a {@link PackedByteArray} containing the result of encrypting (or decrypting) the given `src`. See {@link start} for mode of operation.
+     * **Note:** The size of `src` must be a multiple of 16. Apply some padding if needed.
+     */
+    update(src: PackedByteArray): PackedByteArray { return _C(this, 14502, src) as PackedByteArray; }
+
+    /**
+     * Get the current IV state for this context (IV gets updated when calling {@link update}). You normally don't need this function.
+     * **Note:** This function only makes sense when the context is started with {@link MODE_CBC_ENCRYPT} or {@link MODE_CBC_DECRYPT}.
+     */
+    getIvState(): PackedByteArray { return _C(this, 5219) as PackedByteArray; }
+
+    /**
+     * Close this AES context so it can be started again. See {@link start}.
+     */
+    finish(): void { _C(this, 3309); }
+
+    static readonly name = _R(41, AESContext);
+}
+
+export const Mode = {
+    /**
+     * AES electronic codebook encryption mode.
+     */
+    MODE_ECB_ENCRYPT: 0,
+    /**
+     * AES electronic codebook decryption mode.
+     */
+    MODE_ECB_DECRYPT: 1,
+    /**
+     * AES cipher block chaining encryption mode.
+     */
+    MODE_CBC_ENCRYPT: 2,
+    /**
+     * AES cipher block chaining decryption mode.
+     */
+    MODE_CBC_DECRYPT: 3,
+    /**
+     * Maximum value for the mode enum.
+     */
+    MODE_MAX: 4,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+

package/gen/classes/AStar2D.ts

@@ -0,0 +1,222 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { PackedInt64Array, PackedVector2Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * An implementation of the A* algorithm, used to find the shortest path between two vertices on a connected graph in 2D space.
+ * See {@link AStar3D} for a more thorough explanation on how to use this class. {@link AStar2D} is a wrapper for {@link AStar3D} that enforces 2D coordinates.
+ */
+export class AStar2D extends RefCounted {
+    constructor(name = 42) { super(name); }
+
+    /**
+     * Returns the next available point ID with no point associated to it.
+     */
+    getAvailablePointId(): number { return _C(this, 3852) as number; }
+
+    /**
+     * Adds a new point at the given position with the given identifier. The `id` must be 0 or larger, and the `weightScale` must be 0.0 or greater.
+     * The `weightScale` is multiplied by the result of {@link _computeCost} when determining the overall cost of traveling across a segment from a neighboring point to this point. Thus, all else being equal, the algorithm prefers points with lower `weightScale`s to form a path.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar2D.new()
+     * astar.add_point(1, Vector2(1, 0), 4) # Adds the point (1, 0) with weight_scale 4 and id 1
+     *
+     * ```
+     *
+     *
+     *
+     * If there already exists a point for the given `id`, its position and weight scale are updated to the given values.
+     */
+    addPoint(id: number /* int64 */, position: Vector2, weightScale?: number /* = 1.0 */): void { _C(this, 1272, id, position, weightScale); }
+
+    /**
+     * Returns the position of the point associated with the given `id`.
+     */
+    getPointPosition(id: number /* int64 */): Vector2 { return _C(this, 5951, id) as Vector2; }
+
+    /**
+     * Sets the `position` for the point with the given `id`.
+     */
+    setPointPosition(id: number /* int64 */, position: Vector2): void { _C(this, 12361, id, position); }
+
+    /**
+     * Returns the weight scale of the point associated with the given `id`.
+     */
+    getPointWeightScale(id: number /* int64 */): number { return _C(this, 5957, id) as number; }
+
+    /**
+     * Sets the `weightScale` for the point with the given `id`. The `weightScale` is multiplied by the result of {@link _computeCost} when determining the overall cost of traveling across a segment from a neighboring point to this point.
+     */
+    setPointWeightScale(id: number /* int64 */, weightScale: number): void { _C(this, 12368, id, weightScale); }
+
+    /**
+     * Removes the point associated with the given `id` from the points pool.
+     */
+    removePoint(id: number /* int64 */): void { _C(this, 9948, id); }
+
+    /**
+     * Returns whether a point associated with the given `id` exists.
+     */
+    hasPoint(id: number /* int64 */): boolean { return _C(this, 7430, id) as boolean; }
+
+    /**
+     * Returns an array with the IDs of the points that form the connection with the given point.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar2D.new()
+     * astar.add_point(1, Vector2(0, 0))
+     * astar.add_point(2, Vector2(0, 1))
+     * astar.add_point(3, Vector2(1, 1))
+     * astar.add_point(4, Vector2(2, 0))
+     *
+     * astar.connect_points(1, 2, true)
+     * astar.connect_points(1, 3, true)
+     *
+     * var neighbors = astar.get_point_connections(1) # Returns [2, 3]
+     *
+     * ```
+     */
+    getPointConnections(id: number /* int64 */): PackedInt64Array { return _C(this, 5941, id) as PackedInt64Array; }
+
+    /**
+     * Returns an array of all point IDs.
+     */
+    getPointIds(): PackedInt64Array { return _C(this, 5944) as PackedInt64Array; }
+
+    /**
+     * Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle.
+     */
+    setPointDisabled(id: number /* int64 */, disabled?: boolean /* = true */): void { _C(this, 12353, id, disabled); }
+
+    /**
+     * Returns whether a point is disabled or not for pathfinding. By default, all points are enabled.
+     */
+    isPointDisabled(id: number /* int64 */): boolean { return _C(this, 8184, id) as boolean; }
+
+    /**
+     * Creates a segment between the given points. If `bidirectional` is `false`, only movement from `id` to `toId` is allowed, not the reverse direction.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar2D.new()
+     * astar.add_point(1, Vector2(1, 1))
+     * astar.add_point(2, Vector2(0, 5))
+     * astar.connect_points(1, 2, false)
+     *
+     * ```
+     */
+    connectPoints(id: number /* int64 */, toId: number /* int64 */, bidirectional?: boolean /* = true */): void { _C(this, 2437, id, toId, bidirectional); }
+
+    /**
+     * Deletes the segment between the given points. If `bidirectional` is `false`, only movement from `id` to `toId` is prevented, and a unidirectional segment possibly remains.
+     */
+    disconnectPoints(id: number /* int64 */, toId: number /* int64 */, bidirectional?: boolean /* = true */): void { _C(this, 2828, id, toId, bidirectional); }
+
+    /**
+     * Returns whether there is a connection/segment between the given points. If `bidirectional` is `false`, returns whether movement from `id` to `toId` is possible through this segment.
+     */
+    arePointsConnected(id: number /* int64 */, toId: number /* int64 */, bidirectional?: boolean /* = true */): boolean { return _C(this, 1545, id, toId, bidirectional) as boolean; }
+
+    /**
+     * Returns the number of points currently in the points pool.
+     */
+    getPointCount(): number { return _C(this, 5942) as number; }
+
+    /**
+     * Returns the capacity of the structure backing the points, useful in conjunction with {@link reserveSpace}.
+     */
+    getPointCapacity(): number { return _C(this, 5940) as number; }
+
+    /**
+     * Reserves space internally for `numNodes` points. Useful if you're adding a known large number of points at once, such as points on a grid.
+     */
+    reserveSpace(numNodes: number /* int64 */): void { _C(this, 10063, numNodes); }
+
+    /**
+     * Clears all the points and segments.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns the ID of the closest point to `toPosition`, optionally taking disabled points into account. Returns `-1` if there are no points in the points pool.
+     * **Note:** If several points are the closest to `toPosition`, the one with the smallest ID will be returned, ensuring a deterministic result.
+     */
+    getClosestPoint(toPosition: Vector2, includeDisabled?: boolean /* = false */): number { return _C(this, 4174, toPosition, includeDisabled) as number; }
+
+    /**
+     * Returns the closest position to `toPosition` that resides inside a segment between two connected points.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar2D.new()
+     * astar.add_point(1, Vector2(0, 0))
+     * astar.add_point(2, Vector2(0, 5))
+     * astar.connect_points(1, 2)
+     * var res = astar.get_closest_position_in_segment(Vector2(3, 3)) # Returns (0, 3)
+     *
+     * ```
+     *
+     *
+     *
+     * The result is in the segment that goes from `y = 0` to `y = 5`. It's the closest position in the segment to the given point.
+     */
+    getClosestPositionInSegment(toPosition: Vector2): Vector2 { return _C(this, 4178, toPosition) as Vector2; }
+
+    /**
+     * Returns an array with the points that are in the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path.
+     * If `fromId` point is disabled, returns an empty array (even if `from_id == to_id`).
+     * If `fromId` point is not disabled, there is no valid path to the target, and `allowPartialPath` is `true`, returns a path to the point closest to the target that can be reached.
+     * **Note:** This method is not thread-safe; it can only be used from a single {@link Thread} at a given time. Consider using {@link Mutex} to ensure exclusive access to one thread to avoid race conditions.
+     * Additionally, when `allowPartialPath` is `true` and `toId` is disabled the search may take an unusually long time to finish.
+     */
+    getPointPath(fromId: number /* int64 */, toId: number /* int64 */, allowPartialPath?: boolean /* = false */): PackedVector2Array { return _C(this, 5949, fromId, toId, allowPartialPath) as PackedVector2Array; }
+
+    /**
+     * Returns an array with the IDs of the points that form the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path.
+     * If `fromId` point is disabled, returns an empty array (even if `from_id == to_id`).
+     * If `fromId` point is not disabled, there is no valid path to the target, and `allowPartialPath` is `true`, returns a path to the point closest to the target that can be reached.
+     * **Note:** When `allowPartialPath` is `true` and `toId` is disabled the search may take an unusually long time to finish.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar2D.new()
+     * astar.add_point(1, Vector2(0, 0))
+     * astar.add_point(2, Vector2(0, 1), 1) # Default weight is 1
+     * astar.add_point(3, Vector2(1, 1))
+     * astar.add_point(4, Vector2(2, 0))
+     *
+     * astar.connect_points(1, 2, false)
+     * astar.connect_points(2, 3, false)
+     * astar.connect_points(4, 3, false)
+     * astar.connect_points(1, 4, false)
+     *
+     * var res = astar.get_id_path(1, 3) # Returns [1, 2, 3]
+     *
+     * ```
+     *
+     *
+     *
+     * If you change the 2nd point's weight to 3, then the result will be `[1, 4, 3]` instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2.
+     */
+    getIdPath(fromId: number /* int64 */, toId: number /* int64 */, allowPartialPath?: boolean /* = false */): PackedInt64Array { return _C(this, 5064, fromId, toId, allowPartialPath) as PackedInt64Array; }
+
+    /**
+     * If `true` enables the filtering of neighbors via {@link _filterNeighbor}.
+     */
+    get neighborFilterEnabled(): boolean { return _C(this, 8132) as boolean; }
+    set neighborFilterEnabled(v: boolean) { _C(this, 12130, v); }
+
+    static readonly name = _R(42, AStar2D);
+}

package/gen/classes/AStar3D.ts

@@ -0,0 +1,247 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { PackedInt64Array, PackedVector3Array } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * A* (A star) is a computer algorithm used in pathfinding and graph traversal, the process of plotting short paths among vertices (points), passing through a given set of edges (segments). It enjoys widespread use due to its performance and accuracy. Godot's A* implementation uses points in 3D space and Euclidean distances by default.
+ * You must add points manually with {@link addPoint} and create segments manually with {@link connectPoints}. Once done, you can test if there is a path between two points with the {@link arePointsConnected} function, get a path containing indices by {@link getIdPath}, or one containing actual coordinates with {@link getPointPath}.
+ * It is also possible to use non-Euclidean distances. To do so, create a script that extends {@link AStar3D} and override the methods {@link _computeCost} and {@link _estimateCost}. Both should take two point IDs and return the distance between the corresponding points.
+ * **Example:** Use Manhattan distance instead of Euclidean distance:
+ *
+ *
+ * ```gdscript
+ *
+ * class_name MyAStar3D
+ * extends AStar3D
+ *
+ * func _compute_cost(u, v):
+ * 	var u_pos = get_point_position(u)
+ * 	var v_pos = get_point_position(v)
+ * 	return abs(u_pos.x - v_pos.x) + abs(u_pos.y - v_pos.y) + abs(u_pos.z - v_pos.z)
+ *
+ * func _estimate_cost(u, v):
+ * 	var u_pos = get_point_position(u)
+ * 	var v_pos = get_point_position(v)
+ * 	return abs(u_pos.x - v_pos.x) + abs(u_pos.y - v_pos.y) + abs(u_pos.z - v_pos.z)
+ *
+ * ```
+ *
+ *
+ *
+ * {@link _estimateCost} should return a lower bound of the distance, i.e. `_estimate_cost(u, v) <= _compute_cost(u, v)`. This serves as a hint to the algorithm because the custom {@link _computeCost} might be computation-heavy. If this is not the case, make {@link _estimateCost} return the same value as {@link _computeCost} to provide the algorithm with the most accurate information.
+ * If the default {@link _estimateCost} and {@link _computeCost} methods are used, or if the supplied {@link _estimateCost} method returns a lower bound of the cost, then the paths returned by A* will be the lowest-cost paths. Here, the cost of a path equals the sum of the {@link _computeCost} results of all segments in the path multiplied by the `weight_scale`s of the endpoints of the respective segments. If the default methods are used and the `weight_scale`s of all points are set to `1.0`, then this equals the sum of Euclidean distances of all segments in the path.
+ */
+export class AStar3D extends RefCounted {
+    constructor(name = 43) { super(name); }
+
+    /**
+     * Returns the next available point ID with no point associated to it.
+     */
+    getAvailablePointId(): number { return _C(this, 3852) as number; }
+
+    /**
+     * Adds a new point at the given position with the given identifier. The `id` must be 0 or larger, and the `weightScale` must be 0.0 or greater.
+     * The `weightScale` is multiplied by the result of {@link _computeCost} when determining the overall cost of traveling across a segment from a neighboring point to this point. Thus, all else being equal, the algorithm prefers points with lower `weightScale`s to form a path.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar3D.new()
+     * astar.add_point(1, Vector3(1, 0, 0), 4) # Adds the point (1, 0, 0) with weight_scale 4 and id 1
+     *
+     * ```
+     *
+     *
+     *
+     * If there already exists a point for the given `id`, its position and weight scale are updated to the given values.
+     */
+    addPoint(id: number /* int64 */, position: Vector3, weightScale?: number /* = 1.0 */): void { _C(this, 1272, id, position, weightScale); }
+
+    /**
+     * Returns the position of the point associated with the given `id`.
+     */
+    getPointPosition(id: number /* int64 */): Vector3 { return _C(this, 5951, id) as Vector3; }
+
+    /**
+     * Sets the `position` for the point with the given `id`.
+     */
+    setPointPosition(id: number /* int64 */, position: Vector3): void { _C(this, 12361, id, position); }
+
+    /**
+     * Returns the weight scale of the point associated with the given `id`.
+     */
+    getPointWeightScale(id: number /* int64 */): number { return _C(this, 5957, id) as number; }
+
+    /**
+     * Sets the `weightScale` for the point with the given `id`. The `weightScale` is multiplied by the result of {@link _computeCost} when determining the overall cost of traveling across a segment from a neighboring point to this point.
+     */
+    setPointWeightScale(id: number /* int64 */, weightScale: number): void { _C(this, 12368, id, weightScale); }
+
+    /**
+     * Removes the point associated with the given `id` from the points pool.
+     */
+    removePoint(id: number /* int64 */): void { _C(this, 9948, id); }
+
+    /**
+     * Returns whether a point associated with the given `id` exists.
+     */
+    hasPoint(id: number /* int64 */): boolean { return _C(this, 7430, id) as boolean; }
+
+    /**
+     * Returns an array with the IDs of the points that form the connection with the given point.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar3D.new()
+     * astar.add_point(1, Vector3(0, 0, 0))
+     * astar.add_point(2, Vector3(0, 1, 0))
+     * astar.add_point(3, Vector3(1, 1, 0))
+     * astar.add_point(4, Vector3(2, 0, 0))
+     *
+     * astar.connect_points(1, 2, true)
+     * astar.connect_points(1, 3, true)
+     *
+     * var neighbors = astar.get_point_connections(1) # Returns [2, 3]
+     *
+     * ```
+     */
+    getPointConnections(id: number /* int64 */): PackedInt64Array { return _C(this, 5941, id) as PackedInt64Array; }
+
+    /**
+     * Returns an array of all point IDs.
+     */
+    getPointIds(): PackedInt64Array { return _C(this, 5944) as PackedInt64Array; }
+
+    /**
+     * Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle.
+     */
+    setPointDisabled(id: number /* int64 */, disabled?: boolean /* = true */): void { _C(this, 12353, id, disabled); }
+
+    /**
+     * Returns whether a point is disabled or not for pathfinding. By default, all points are enabled.
+     */
+    isPointDisabled(id: number /* int64 */): boolean { return _C(this, 8184, id) as boolean; }
+
+    /**
+     * Creates a segment between the given points. If `bidirectional` is `false`, only movement from `id` to `toId` is allowed, not the reverse direction.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar3D.new()
+     * astar.add_point(1, Vector3(1, 1, 0))
+     * astar.add_point(2, Vector3(0, 5, 0))
+     * astar.connect_points(1, 2, false)
+     *
+     * ```
+     */
+    connectPoints(id: number /* int64 */, toId: number /* int64 */, bidirectional?: boolean /* = true */): void { _C(this, 2437, id, toId, bidirectional); }
+
+    /**
+     * Deletes the segment between the given points. If `bidirectional` is `false`, only movement from `id` to `toId` is prevented, and a unidirectional segment possibly remains.
+     */
+    disconnectPoints(id: number /* int64 */, toId: number /* int64 */, bidirectional?: boolean /* = true */): void { _C(this, 2828, id, toId, bidirectional); }
+
+    /**
+     * Returns whether the two given points are directly connected by a segment. If `bidirectional` is `false`, returns whether movement from `id` to `toId` is possible through this segment.
+     */
+    arePointsConnected(id: number /* int64 */, toId: number /* int64 */, bidirectional?: boolean /* = true */): boolean { return _C(this, 1545, id, toId, bidirectional) as boolean; }
+
+    /**
+     * Returns the number of points currently in the points pool.
+     */
+    getPointCount(): number { return _C(this, 5942) as number; }
+
+    /**
+     * Returns the capacity of the structure backing the points, useful in conjunction with {@link reserveSpace}.
+     */
+    getPointCapacity(): number { return _C(this, 5940) as number; }
+
+    /**
+     * Reserves space internally for `numNodes` points. Useful if you're adding a known large number of points at once, such as points on a grid.
+     */
+    reserveSpace(numNodes: number /* int64 */): void { _C(this, 10063, numNodes); }
+
+    /**
+     * Clears all the points and segments.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns the ID of the closest point to `toPosition`, optionally taking disabled points into account. Returns `-1` if there are no points in the points pool.
+     * **Note:** If several points are the closest to `toPosition`, the one with the smallest ID will be returned, ensuring a deterministic result.
+     */
+    getClosestPoint(toPosition: Vector3, includeDisabled?: boolean /* = false */): number { return _C(this, 4174, toPosition, includeDisabled) as number; }
+
+    /**
+     * Returns the closest position to `toPosition` that resides inside a segment between two connected points.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar3D.new()
+     * astar.add_point(1, Vector3(0, 0, 0))
+     * astar.add_point(2, Vector3(0, 5, 0))
+     * astar.connect_points(1, 2)
+     * var res = astar.get_closest_position_in_segment(Vector3(3, 3, 0)) # Returns (0, 3, 0)
+     *
+     * ```
+     *
+     *
+     *
+     * The result is in the segment that goes from `y = 0` to `y = 5`. It's the closest position in the segment to the given point.
+     */
+    getClosestPositionInSegment(toPosition: Vector3): Vector3 { return _C(this, 4178, toPosition) as Vector3; }
+
+    /**
+     * Returns an array with the points that are in the path found by AStar3D between the given points. The array is ordered from the starting point to the ending point of the path.
+     * If `fromId` point is disabled, returns an empty array (even if `from_id == to_id`).
+     * If `fromId` point is not disabled, there is no valid path to the target, and `allowPartialPath` is `true`, returns a path to the point closest to the target that can be reached.
+     * **Note:** This method is not thread-safe; it can only be used from a single {@link Thread} at a given time. Consider using {@link Mutex} to ensure exclusive access to one thread to avoid race conditions.
+     * Additionally, when `allowPartialPath` is `true` and `toId` is disabled the search may take an unusually long time to finish.
+     */
+    getPointPath(fromId: number /* int64 */, toId: number /* int64 */, allowPartialPath?: boolean /* = false */): PackedVector3Array { return _C(this, 5949, fromId, toId, allowPartialPath) as PackedVector3Array; }
+
+    /**
+     * Returns an array with the IDs of the points that form the path found by AStar3D between the given points. The array is ordered from the starting point to the ending point of the path.
+     * If `fromId` point is disabled, returns an empty array (even if `from_id == to_id`).
+     * If `fromId` point is not disabled, there is no valid path to the target, and `allowPartialPath` is `true`, returns a path to the point closest to the target that can be reached.
+     * **Note:** When `allowPartialPath` is `true` and `toId` is disabled the search may take an unusually long time to finish.
+     *
+     *
+     * ```gdscript
+     *
+     * var astar = AStar3D.new()
+     * astar.add_point(1, Vector3(0, 0, 0))
+     * astar.add_point(2, Vector3(0, 1, 0), 1) # Default weight is 1
+     * astar.add_point(3, Vector3(1, 1, 0))
+     * astar.add_point(4, Vector3(2, 0, 0))
+     *
+     * astar.connect_points(1, 2, false)
+     * astar.connect_points(2, 3, false)
+     * astar.connect_points(4, 3, false)
+     * astar.connect_points(1, 4, false)
+     *
+     * var res = astar.get_id_path(1, 3) # Returns [1, 2, 3]
+     *
+     * ```
+     *
+     *
+     *
+     * If you change the 2nd point's weight to 3, then the result will be `[1, 4, 3]` instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2.
+     */
+    getIdPath(fromId: number /* int64 */, toId: number /* int64 */, allowPartialPath?: boolean /* = false */): PackedInt64Array { return _C(this, 5064, fromId, toId, allowPartialPath) as PackedInt64Array; }
+
+    /**
+     * If `true` enables the filtering of neighbors via {@link _filterNeighbor}.
+     */
+    get neighborFilterEnabled(): boolean { return _C(this, 8132) as boolean; }
+    set neighborFilterEnabled(v: boolean) { _C(this, 12130, v); }
+
+    static readonly name = _R(43, AStar3D);
+}