@ringozz/godot 0.1.0

package/gen/classes/AStarGrid2D.ts

@@ -0,0 +1,284 @@
+// 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 { GodotArray, GodotDictionary, PackedVector2Array } from '../heap-types/index.ts';
+import type { Rect2i, Vector2, Vector2i } from '../value-types/index.ts';
+
+/**
+ * {@link AStarGrid2D} is a variant of {@link AStar2D} that is specialized for partial 2D grids. It is simpler to use because it doesn't require you to manually create points and connect them together. This class also supports multiple types of heuristics, modes for diagonal movement, and a jumping mode to speed up calculations.
+ * To use {@link AStarGrid2D}, you only need to set the {@link region} of the grid, optionally set the {@link cellSize}, and then call the {@link update} method:
+ *
+ *
+ * ```gdscript
+ *
+ * var astar_grid = AStarGrid2D.new()
+ * astar_grid.region = Rect2i(0, 0, 32, 32)
+ * astar_grid.cell_size = Vector2(16, 16)
+ * astar_grid.update()
+ * print(astar_grid.get_id_path(Vector2i(0, 0), Vector2i(3, 4))) # Prints [(0, 0), (1, 1), (2, 2), (3, 3), (3, 4)]
+ * print(astar_grid.get_point_path(Vector2i(0, 0), Vector2i(3, 4))) # Prints [(0, 0), (16, 16), (32, 32), (48, 48), (48, 64)]
+ *
+ * ```
+ *
+ *
+ *
+ * To remove a point from the pathfinding grid, it must be set as "solid" with {@link setPointSolid}.
+ */
+export class AStarGrid2D extends RefCounted {
+    constructor(name = 44) { super(name); }
+
+    /**
+     * Returns `true` if the `x` and `y` is a valid grid coordinate (id), i.e. if it is inside {@link region}. Equivalent to `region.has_point(Vector2i(x, y))`.
+     */
+    isInBounds(x: number, y: number): boolean { return _C(this, 8010, x, y) as boolean; }
+
+    /**
+     * Returns `true` if the `id` vector is a valid grid coordinate, i.e. if it is inside {@link region}. Equivalent to `region.has_point(id)`.
+     */
+    isInBoundsv(id: Vector2i): boolean { return _C(this, 8011, id) as boolean; }
+
+    /**
+     * Indicates that the grid parameters were changed and {@link update} needs to be called.
+     */
+    isDirty(): boolean { return _C(this, 7882) as boolean; }
+
+    /**
+     * Updates the internal state of the grid according to the parameters to prepare it to search the path. Needs to be called if parameters like {@link region}, {@link cellSize} or {@link offset} are changed. {@link isDirty} will return `true` if this is the case and this needs to be called.
+     * **Note:** All point data (solidity and weight scale) will be cleared.
+     */
+    update(): void { _C(this, 14502); }
+
+    /**
+     * Disables or enables the specified point for pathfinding. Useful for making an obstacle. By default, all points are enabled.
+     * **Note:** Calling {@link update} is not needed after the call of this function.
+     */
+    setPointSolid(id: Vector2i, solid?: boolean /* = true */): void { _C(this, 12365, id, solid); }
+
+    /**
+     * Returns `true` if a point is disabled for pathfinding. By default, all points are enabled.
+     */
+    isPointSolid(id: Vector2i): boolean { return _C(this, 8190, id) as boolean; }
+
+    /**
+     * 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.
+     * **Note:** Calling {@link update} is not needed after the call of this function.
+     */
+    setPointWeightScale(id: Vector2i, weightScale: number): void { _C(this, 12368, id, weightScale); }
+
+    /**
+     * Returns the weight scale of the point associated with the given `id`.
+     */
+    getPointWeightScale(id: Vector2i): number { return _C(this, 5957, id) as number; }
+
+    /**
+     * Fills the given `region` on the grid with the specified value for the solid flag.
+     * **Note:** Calling {@link update} is not needed after the call of this function.
+     */
+    fillSolidRegion(region: Rect2i, solid?: boolean /* = true */): void { _C(this, 3264, region, solid); }
+
+    /**
+     * Fills the given `region` on the grid with the specified value for the weight scale.
+     * **Note:** Calling {@link update} is not needed after the call of this function.
+     */
+    fillWeightScaleRegion(region: Rect2i, weightScale: number): void { _C(this, 3266, region, weightScale); }
+
+    /**
+     * Clears the grid and sets the {@link region} to `Rect2i(0, 0, 0, 0)`.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns the position of the point associated with the given `id`.
+     */
+    getPointPosition(id: Vector2i): Vector2 { return _C(this, 5951, id) as Vector2; }
+
+    /**
+     * Returns an array of dictionaries with point data (`id`: {@link Vector2i}, `position`: {@link Vector2}, `solid`: {@link bool}, `weight_scale`: {@link float}) within a `region`.
+     */
+    getPointDataInRegion(region: Rect2i): GodotArray<GodotDictionary> { return _C(this, 5943, region) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns an array with the points that are in the path found by {@link AStarGrid2D} 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 solid the search may take an unusually long time to finish.
+     */
+    getPointPath(fromId: Vector2i, toId: Vector2i, 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 solid the search may take an unusually long time to finish.
+     */
+    getIdPath(fromId: Vector2i, toId: Vector2i, allowPartialPath?: boolean /* = false */): GodotArray<Vector2i> { return _C(this, 5064, fromId, toId, allowPartialPath) as GodotArray<Vector2i>; }
+
+    /**
+     * The region of grid cells available for pathfinding. If changed, {@link update} needs to be called before finding the next path.
+     */
+    get region(): Rect2i { return _C(this, 6112) as Rect2i; }
+    set region(v: Rect2i) { _C(this, 12505, v); }
+
+    /**
+     * The size of the grid (number of cells of size {@link cellSize} on each axis). If changed, {@link update} needs to be called before finding the next path.
+     */
+    get size(): Vector2i { return _C(this, 6399) as Vector2i; }
+    set size(v: Vector2i) { _C(this, 12752, v); }
+
+    /**
+     * The offset of the grid which will be applied to calculate the resulting point position returned by {@link getPointPath}. If changed, {@link update} needs to be called before finding the next path.
+     */
+    get offset(): Vector2 { return _C(this, 5703) as Vector2; }
+    set offset(v: Vector2) { _C(this, 12170, v); }
+
+    /**
+     * The size of the point cell which will be applied to calculate the resulting point position returned by {@link getPointPath}. If changed, {@link update} needs to be called before finding the next path.
+     */
+    get cellSize(): Vector2 { return _C(this, 4115) as Vector2; }
+    set cellSize(v: Vector2) { _C(this, 10829, v); }
+
+    /**
+     * The cell shape. Affects how the positions are placed in the grid. If changed, {@link update} needs to be called before finding the next path.
+     */
+    get cellShape(): CellShape { return _C(this, 4114) as CellShape; }
+    set cellShape(v: CellShape) { _C(this, 10828, v); }
+
+    /**
+     * Enables or disables jumping to skip up the intermediate points and speeds up the searching algorithm.
+     * **Note:** Currently, toggling it on disables the consideration of weight scaling in pathfinding.
+     */
+    get jumpingEnabled(): boolean { return _C(this, 8055) as boolean; }
+    set jumpingEnabled(v: boolean) { _C(this, 11852, v); }
+
+    /**
+     * The default {@link Heuristic} which will be used to calculate the cost between two points if {@link _computeCost} was not overridden.
+     */
+    get defaultComputeHeuristic(): Heuristic { return _C(this, 4446) as Heuristic; }
+    set defaultComputeHeuristic(v: Heuristic) { _C(this, 11059, v); }
+
+    /**
+     * The default {@link Heuristic} which will be used to calculate the cost between the point and the end point if {@link _estimateCost} was not overridden.
+     */
+    get defaultEstimateHeuristic(): Heuristic { return _C(this, 4448) as Heuristic; }
+    set defaultEstimateHeuristic(v: Heuristic) { _C(this, 11061, v); }
+
+    /**
+     * A specific {@link DiagonalMode} mode which will force the path to avoid or accept the specified diagonals.
+     */
+    get diagonalMode(): DiagonalMode { return _C(this, 4500) as DiagonalMode; }
+    set diagonalMode(v: DiagonalMode) { _C(this, 11107, v); }
+
+    static readonly name = _R(44, AStarGrid2D);
+}
+
+export const Heuristic = {
+    /**
+     * The [Euclidean heuristic](https://en.wikipedia.org/wiki/Euclidean_distance) to be used for the pathfinding using the following formula:
+     *
+     * ```text
+     *
+     * dx = abs(to_id.x - from_id.x)
+     * dy = abs(to_id.y - from_id.y)
+     * result = sqrt(dx * dx + dy * dy)
+     *
+     * ```
+     *
+     * **Note:** This is also the internal heuristic used in {@link AStar3D} and {@link AStar2D} by default (with the inclusion of possible z-axis coordinate).
+     */
+    HEURISTIC_EUCLIDEAN: 0,
+    /**
+     * The [Manhattan heuristic](https://en.wikipedia.org/wiki/Taxicab_geometry) to be used for the pathfinding using the following formula:
+     *
+     * ```text
+     *
+     * dx = abs(to_id.x - from_id.x)
+     * dy = abs(to_id.y - from_id.y)
+     * result = dx + dy
+     *
+     * ```
+     *
+     * **Note:** This heuristic is intended to be used with 4-side orthogonal movements, provided by setting the {@link diagonalMode} to {@link DIAGONAL_MODE_NEVER}.
+     */
+    HEURISTIC_MANHATTAN: 1,
+    /**
+     * The Octile heuristic to be used for the pathfinding using the following formula:
+     *
+     * ```text
+     *
+     * dx = abs(to_id.x - from_id.x)
+     * dy = abs(to_id.y - from_id.y)
+     * f = sqrt(2) - 1
+     * result = (dx < dy) ? f * dx + dy : f * dy + dx;
+     *
+     * ```
+     */
+    HEURISTIC_OCTILE: 2,
+    /**
+     * The [Chebyshev heuristic](https://en.wikipedia.org/wiki/Chebyshev_distance) to be used for the pathfinding using the following formula:
+     *
+     * ```text
+     *
+     * dx = abs(to_id.x - from_id.x)
+     * dy = abs(to_id.y - from_id.y)
+     * result = max(dx, dy)
+     *
+     * ```
+     */
+    HEURISTIC_CHEBYSHEV: 3,
+    /**
+     * Represents the size of the {@link Heuristic} enum.
+     */
+    HEURISTIC_MAX: 4,
+} as const;
+
+export type Heuristic = (typeof Heuristic)[keyof typeof Heuristic];
+
+export const DiagonalMode = {
+    /**
+     * The pathfinding algorithm will ignore solid neighbors around the target cell and allow passing using diagonals.
+     */
+    DIAGONAL_MODE_ALWAYS: 0,
+    /**
+     * The pathfinding algorithm will ignore all diagonals and the way will be always orthogonal.
+     */
+    DIAGONAL_MODE_NEVER: 1,
+    /**
+     * The pathfinding algorithm will avoid using diagonals if at least two obstacles have been placed around the neighboring cells of the specific path segment.
+     */
+    DIAGONAL_MODE_AT_LEAST_ONE_WALKABLE: 2,
+    /**
+     * The pathfinding algorithm will avoid using diagonals if any obstacle has been placed around the neighboring cells of the specific path segment.
+     */
+    DIAGONAL_MODE_ONLY_IF_NO_OBSTACLES: 3,
+    /**
+     * Represents the size of the {@link DiagonalMode} enum.
+     */
+    DIAGONAL_MODE_MAX: 4,
+} as const;
+
+export type DiagonalMode = (typeof DiagonalMode)[keyof typeof DiagonalMode];
+
+export const CellShape = {
+    /**
+     * Rectangular cell shape.
+     */
+    CELL_SHAPE_SQUARE: 0,
+    /**
+     * Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes up-right, and the vertical one goes down-right.
+     */
+    CELL_SHAPE_ISOMETRIC_RIGHT: 1,
+    /**
+     * Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes down-right, and the vertical one goes down-left.
+     */
+    CELL_SHAPE_ISOMETRIC_DOWN: 2,
+    /**
+     * Represents the size of the {@link CellShape} enum.
+     */
+    CELL_SHAPE_MAX: 3,
+} as const;
+
+export type CellShape = (typeof CellShape)[keyof typeof CellShape];
+

package/gen/classes/AcceptDialog.ts

@@ -0,0 +1,104 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Window } from './Window.ts';
+import type { Signal, StringName } from '../heap-types/index.ts';
+import type { Button } from './Button.ts';
+import type { Label } from './Label.ts';
+import type { LineEdit } from './LineEdit.ts';
+
+/**
+ * The default use of {@link AcceptDialog} is to allow it to only be accepted or closed, with the same result. However, the {@link confirmed} and {@link canceled} signals allow to make the two actions different, and the {@link addButton} method allows to add custom buttons and actions.
+ * **Note:** {@link AcceptDialog} is invisible by default. To make it visible, call one of the `popup_*` methods from {@link Window} on the node, such as {@link Window.popupCenteredClamped}.
+ */
+export class AcceptDialog extends Window {
+    constructor(name = 45) { super(name); }
+
+    /**
+     * Returns the OK {@link Button} instance.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+     */
+    getOkButton(): Button { return _C(this, 5714) as Button; }
+
+    /**
+     * Returns the label used for built-in text.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+     */
+    getLabel(): Label { return _C(this, 5297) as Label; }
+
+    /**
+     * Adds a button with label `text` and a custom `action` to the dialog and returns the created button.
+     * If `action` is not empty, pressing the button will emit the {@link custom_action} signal with the specified action string.
+     * If `true`, `right` will place the button to the right of any sibling buttons.
+     * You can use {@link removeButton} method to remove a button created with this method from the dialog.
+     */
+    addButton(text: string, right?: boolean /* = false */, action?: string /* = "" */): Button { return _C(this, 1190, text, right, action) as Button; }
+
+    /**
+     * Adds a button with label `name` and a cancel action to the dialog and returns the created button.
+     * You can use {@link removeButton} method to remove a button created with this method from the dialog.
+     */
+    addCancelButton(name: string): Button { return _C(this, 1191, name) as Button; }
+
+    /**
+     * Removes the `button` from the dialog. Does NOT free the `button`. The `button` must be a {@link Button} added with {@link addButton} or {@link addCancelButton} method. After removal, pressing the `button` will no longer emit this dialog's {@link custom_action} or {@link canceled} signals.
+     */
+    removeButton(button: Button): void { _C(this, 9892, button); }
+
+    /**
+     * Registers a {@link LineEdit} in the dialog. When the enter key is pressed, the dialog will be accepted.
+     */
+    registerTextEnter(lineEdit: LineEdit): void { _C(this, 9860, lineEdit); }
+
+    /**
+     * The text displayed by the OK button (see {@link getOkButton}). If empty, a default text will be used.
+     */
+    get okButtonText(): string { return _C(this, 5715) as string; }
+    set okButtonText(v: string) { _C(this, 12182, v); }
+
+    /**
+     * The text displayed by the dialog.
+     */
+    get dialogText(): string { return _C(this, 6718) as string; }
+    set dialogText(v: string) { _C(this, 13020, v); }
+
+    /**
+     * If `true`, the dialog is hidden when the OK button is pressed. You can set it to `false` if you want to do e.g. input validation when receiving the {@link confirmed} signal, and handle hiding the dialog in your own logic.
+     * **Note:** Some nodes derived from this class can have a different default value, and potentially their own built-in logic overriding this setting. For example {@link FileDialog} defaults to `false`, and has its own input validation code that is called when you press OK, which eventually hides the dialog if the input is valid. As such, this property can't be used in {@link FileDialog} to disable hiding the dialog when pressing OK.
+     */
+    get dialogHideOnOk(): boolean { return _C(this, 5037) as boolean; }
+    set dialogHideOnOk(v: boolean) { _C(this, 11626, v); }
+
+    /**
+     * If `true`, the dialog will be hidden when the `ui_close_dialog` action is pressed (by default, this action is bound to `Escape`, or `Cmd + W` on macOS).
+     */
+    get dialogCloseOnEscape(): boolean { return _C(this, 4166) as boolean; }
+    set dialogCloseOnEscape(v: boolean) { _C(this, 10870, v); }
+
+    /**
+     * Sets autowrapping for the text in the dialog.
+     */
+    get dialogAutowrap(): boolean { return _C(this, 7367) as boolean; }
+    set dialogAutowrap(v: boolean) { _C(this, 10595, v); }
+
+    /**
+     * Emitted when the dialog is accepted, i.e. the OK button is pressed.
+     */
+    get confirmed(): Signal<() => void> { return _G(this, 2432) as Signal<() => void>; }
+    set confirmed(v: (() => void) | null) { _G(this, 2432, v); }
+
+    /**
+     * Emitted when the dialog is closed or the button created with {@link addCancelButton} is pressed.
+     */
+    get canceled(): Signal<() => void> { return _G(this, 2025) as Signal<() => void>; }
+    set canceled(v: (() => void) | null) { _G(this, 2025, v); }
+
+    /**
+     * Emitted when a custom button with an action is pressed. See {@link addButton}.
+     */
+    get customAction(): Signal<(action: StringName) => void> { return _G(this, 2619) as Signal<(action: StringName) => void>; }
+    set customAction(v: ((action: StringName) => void) | null) { _G(this, 2619, v); }
+
+    static readonly name = _R(45, AcceptDialog);
+}