AStarGrid2D

public AStarGrid2D();

Creates an empty grid. Set Region, CellSize/Offset/CellShape, call Update, then apply obstacles and weights. Adjacent-cell connections are implicit; no ConnectPoints call is needed. Dispose the owned RefCounted instance.

public AStarGrid2D.CellShapeEnum CellShape { get; set; }

Selects Square, IsometricRight or IsometricDown for mapping IDs to positions. Changes require Update. Isometric mapping creates no collisions and does not change IDs or DiagonalMode adjacency. Max is an enum boundary, not a shape.

public Vector2 CellSize { get; set; }

Scale mapping IDs to Vector2 positions. For Square, position = Offset + Vector2(id) * CellSize; IDs are not relative to Region origin. Changes require Update, resetting cell overrides. Default costs use IDs, so this scale does not define world-unit route costs. Supply finite meaningful dimensions.

public AStarGrid2D.Heuristic DefaultComputeHeuristic { get; set; }

Default transition-cost formula without a _ComputeCost override. Uses integer-ID differences: Euclidean=sqrt(dx²+dy²), Manhattan=dx+dy, Octile=max(dx,dy)+(sqrt(2)−1)*min(dx,dy), Chebyshev=max(dx,dy). Independent of CellSize/Offset. Ordinary search additionally applies destination weight. Changes require no Update.

public AStarGrid2D.Heuristic DefaultEstimateHeuristic { get; set; }

Default remaining-cost estimate without an _EstimateCost override; not a charged transition. It must be admissible and consistent with movement and weights. Manhattan suits four-direction movement; do not automatically use it for cheaper diagonals. Weights <1/custom costs can require an override returning 0. Changes require no Update.

public AStarGrid2D.DiagonalModeEnum DiagonalMode { get; set; }

Diagonal policy, changeable without Update: Always permits corner cutting even between two solid side cells; Never allows four directions; AtLeastOneWalkable requires one free side cell; OnlyIfNoObstacles requires both. The diagonal destination must always be free. This is a cell rule, not a character-radius test.

public bool JumpingEnabled { get; set; }

Enables Jump Point Search without rebuilding. In 1.0.0 this branch ignores weight_scale, so expensive cells may no longer be avoided. Results can contain jump points without intermediate adjacent cells; consecutive array entries need not be adjacent. Use for suitable uniform-cost grids; no universal speedup is guaranteed.

public Vector2 Offset { get; set; }

Offset of returned Vector2 positions, not cell IDs or Region bounds. Changing it marks dirty. Update recalculates positions and resets solid/weights. An approximately equal value may not mark dirty.

public Rect2I Region { get; set; }

Integer cell-ID rectangle: inclusive start, exclusive end; the origin may be negative. Sizes must be ≥0. Changing it marks the grid dirty; call Update before cell/path access. Rebuilding resets solid and weight_scale, so apply them after Update.

public Vector2I Size { get; set; }

Obsolete C# property for Region size without controlling its origin; use Region. Not the pixel size of a cell. Writing a changed size requires Update and loses cell overrides on rebuild.

public void Clear();

Clears points and empties Region; does not restore all settings to defaults. Offset, CellSize and search policies remain. For a new map, assign a new nonempty Region, call Update and reapply obstacles/weights. Not a command to clear obstacles alone.

public void FillSolidRegion(Rect2I region, bool solid = true);

On an initialized grid, sets solid over the supplied rectangle intersected with Region, excluding its end. Cells outside the intersection remain unchanged. No Update required; a later dirty rebuild resets values. An empty intersection changes nothing.

public void FillWeightScaleRegion(Rect2I region, float weightScale);

Assigns one finite weight ≥0 throughout the rectangle intersected with Region; does not mark dirty. Replaces rather than adds to old weights. Jumping ignores weights, and a dirty Update resets them to 1.

public AStarGrid2D.CellShapeEnum GetCellShape();

Reads current CellShape; rebuilds nothing. Selects Square, IsometricRight or IsometricDown for mapping IDs to positions. Changes require Update. Isometric mapping creates no collisions and does not change IDs or DiagonalMode adjacency. Max is an enum boundary, not a shape.

public Vector2 GetCellSize();

Reads current CellSize; rebuilds nothing. Scale mapping IDs to Vector2 positions. For Square, position = Offset + Vector2(id) * CellSize; IDs are not relative to Region origin. Changes require Update, resetting cell overrides. Default costs use IDs, so this scale does not define world-unit route costs. Supply finite meaningful dimensions.

public AStarGrid2D.Heuristic GetDefaultComputeHeuristic();

Reads current DefaultComputeHeuristic; rebuilds nothing. Default transition-cost formula without a _ComputeCost override. Uses integer-ID differences: Euclidean=sqrt(dx²+dy²), Manhattan=dx+dy, Octile=max(dx,dy)+(sqrt(2)−1)*min(dx,dy), Chebyshev=max(dx,dy). Independent of CellSize/Offset. Ordinary search additionally applies destination weight. Changes require no Update.

public AStarGrid2D.Heuristic GetDefaultEstimateHeuristic();

Reads current DefaultEstimateHeuristic; rebuilds nothing. Default remaining-cost estimate without an _EstimateCost override; not a charged transition. It must be admissible and consistent with movement and weights. Manhattan suits four-direction movement; do not automatically use it for cheaper diagonals. Weights <1/custom costs can require an override returning 0. Changes require no Update.

public AStarGrid2D.DiagonalModeEnum GetDiagonalMode();

Reads current DiagonalMode; rebuilds nothing. Diagonal policy, changeable without Update: Always permits corner cutting even between two solid side cells; Never allows four directions; AtLeastOneWalkable requires one free side cell; OnlyIfNoObstacles requires both. The diagonal destination must always be free. This is a cell rule, not a character-radius test.

public Reckfell.Collections.Array<Vector2I> GetIdPath(Vector2I fromId, Vector2I toId);

Returns cell IDs from start to end, including endpoints. Requires a clean grid and both IDs within Region, even for partial queries. A solid start yields empty; a walkable fromId==toId yields one ID. An unreachable/solid goal yields empty with partial=false; true can end at a reached candidate. Check the last ID before declaring arrival. Jumping can omit intermediate cells. Do not run concurrent searches/mutations on one instance.

public Reckfell.Collections.Array<Vector2I> GetIdPath(Vector2I fromId, Vector2I toId, bool allowPartialPath = false);

Returns cell IDs from start to end, including endpoints. Requires a clean grid and both IDs within Region, even for partial queries. A solid start yields empty; a walkable fromId==toId yields one ID. An unreachable/solid goal yields empty with partial=false; true can end at a reached candidate. Check the last ID before declaring arrival. Jumping can omit intermediate cells. Do not run concurrent searches/mutations on one instance.

public Vector2 GetOffset();

Reads current Offset; rebuilds nothing. Offset of returned Vector2 positions, not cell IDs or Region bounds. Changing it marks dirty. Update recalculates positions and resets solid/weights. An approximately equal value may not mark dirty.

public Reckfell.Collections.Array<Reckfell.Collections.Dictionary> GetPointDataInRegion(Rect2I region);

Returns new Dictionary snapshots for the rectangle intersected with Region: id:Vector2I, position:Vector2, solid:bool, weight_scale:float. Requires an initialized grid. Editing a Dictionary does not edit the grid. Dispose owned Dictionary wrappers after use; the typed Array has no Dispose method.

public Vector2[] GetPointPath(Vector2I fromId, Vector2I toId);

Returns route Vector2 positions under the same validity/partial rules as GetIdPath. Geometry comes from CellSize/Offset/CellShape rather than Entity transforms. Not smoothing, physical clearance or character control. Jumping can omit intermediate cells; the array is an independent snapshot.

public Vector2[] GetPointPath(Vector2I fromId, Vector2I toId, bool allowPartialPath = false);

Returns route Vector2 positions under the same validity/partial rules as GetIdPath. Geometry comes from CellSize/Offset/CellShape rather than Entity transforms. Not smoothing, physical clearance or character control. Jumping can omit intermediate cells; the array is an independent snapshot.

public Vector2 GetPointPosition(Vector2I id);

Returns an initialized cell calculated Vector2 position. For Square this is Offset + Vector2(id) * CellSize without subtracting Region.Position; isometric shapes use half-size and transformed axes. Not an automatic Entity world position.

public float GetPointWeightScale(Vector2I id);

Reads an initialized cell stored weight. The value does not prove jumping search uses it. Dirty/invalid IDs produce diagnostics and a zero fallback.

public Rect2I GetRegion();

Reads current Region; rebuilds nothing. Integer cell-ID rectangle: inclusive start, exclusive end; the origin may be negative. Sizes must be ≥0. Changing it marks the grid dirty; call Update before cell/path access. Rebuilding resets solid and weight_scale, so apply them after Update.

public Vector2I GetSize();

Reads Region.Size only. The SDK method is not marked Obsolete although the Size property is; use Region.Size in new code. Returns neither CellSize nor a rebuilt grid.

public bool IsDirty();

Reports geometry changes requiring Update. false does not imply a nonempty or traversable grid: a new instance has an empty Region and dirty=false. IsInBounds tests Region rather than cell-data readiness.

public bool IsInBounds(int x, int y);

Tests x/y against current Region with an exclusive end boundary. Does not check solid state, reachability, dirty state or rebuilt data availability.

public bool IsInBoundsv(Vector2I id);

Same Region test as IsInBounds, taking a Vector2I ID. Being in bounds does not permit dirty-grid access before Update.

public bool IsJumpingEnabled();

Reads current JumpingEnabled; rebuilds nothing. Enables Jump Point Search without rebuilding. In 1.0.0 this branch ignores weight_scale, so expensive cells may no longer be avoided. Results can contain jump points without intermediate adjacent cells; consecutive array entries need not be adjacent. Use for suitable uniform-cost grids; no universal speedup is guaranteed.

public bool IsPointSolid(Vector2I id);

Reads an initialized in-Region cell obstacle flag. Dirty/invalid IDs produce a diagnosed false fallback, not proof of walkability. Check IsDirty and IsInBoundsv first.

public void SetCellShape(AStarGrid2D.CellShapeEnum cellShape);

Sets CellShape. Selects Square, IsometricRight or IsometricDown for mapping IDs to positions. Changes require Update. Isometric mapping creates no collisions and does not change IDs or DiagonalMode adjacency. Max is an enum boundary, not a shape.

public void SetCellSize(Vector2 cellSize);

Sets CellSize. Scale mapping IDs to Vector2 positions. For Square, position = Offset + Vector2(id) * CellSize; IDs are not relative to Region origin. Changes require Update, resetting cell overrides. Default costs use IDs, so this scale does not define world-unit route costs. Supply finite meaningful dimensions.

public void SetDefaultComputeHeuristic(AStarGrid2D.Heuristic heuristic);

Sets DefaultComputeHeuristic. Default transition-cost formula without a _ComputeCost override. Uses integer-ID differences: Euclidean=sqrt(dx²+dy²), Manhattan=dx+dy, Octile=max(dx,dy)+(sqrt(2)−1)*min(dx,dy), Chebyshev=max(dx,dy). Independent of CellSize/Offset. Ordinary search additionally applies destination weight. Changes require no Update.

public void SetDefaultEstimateHeuristic(AStarGrid2D.Heuristic heuristic);

Sets DefaultEstimateHeuristic. Default remaining-cost estimate without an _EstimateCost override; not a charged transition. It must be admissible and consistent with movement and weights. Manhattan suits four-direction movement; do not automatically use it for cheaper diagonals. Weights <1/custom costs can require an override returning 0. Changes require no Update.

public void SetDiagonalMode(AStarGrid2D.DiagonalModeEnum mode);

Sets DiagonalMode. Diagonal policy, changeable without Update: Always permits corner cutting even between two solid side cells; Never allows four directions; AtLeastOneWalkable requires one free side cell; OnlyIfNoObstacles requires both. The diagonal destination must always be free. This is a cell rule, not a character-radius test.

public void SetJumpingEnabled(bool enabled);

Sets JumpingEnabled. Enables Jump Point Search without rebuilding. In 1.0.0 this branch ignores weight_scale, so expensive cells may no longer be avoided. Results can contain jump points without intermediate adjacent cells; consecutive array entries need not be adjacent. Use for suitable uniform-cost grids; no universal speedup is guaranteed.

public void SetOffset(Vector2 offset);

Sets Offset. Offset of returned Vector2 positions, not cell IDs or Region bounds. Changing it marks dirty. Update recalculates positions and resets solid/weights. An approximately equal value may not mark dirty.

public void SetPointSolid(Vector2I id, bool solid = true);

On an initialized grid, marks an existing cell solid=true by default; false opens it. ID must be in Region. Does not mark dirty or require Update. A solid start yields no path; a solid goal permits partial only. A later dirty rebuild erases the flag.

public void SetPointWeightScale(Vector2I id, float weightScale);

Sets a finite nonnegative entry-cost multiplier on an initialized cell; no Update needed. The start cell has no entry charge. Does not block a cell; use solid to forbid it. JumpingEnabled retains the weight but search ignores it. Validate NaN/Infinity yourself.

public void SetRegion(Rect2I region);

Sets Region. Integer cell-ID rectangle: inclusive start, exclusive end; the origin may be negative. Sizes must be ≥0. Changing it marks the grid dirty; call Update before cell/path access. Rebuilding resets solid and weight_scale, so apply them after Update.

public void SetSize(Vector2I size);

Legacy Region-size setter: native setter emits a warning. Unlike the Size property, this C# method is not marked Obsolete in the SDK. Use Region; Region origin remains, and changed size requires Update.

public void Update();

Does nothing when dirty=false. Otherwise recreates Region cells, positions and boundaries and marks clean; ALL solid flags reset to false and weights to 1. Use geometry → Update → obstacles/weights → path. SetPointSolid/SetPointWeightScale do not require Update.

public virtual float _ComputeCost(Vector2I fromId, Vector2I toId);

Overrides base transition cost between IDs. Ordinary search additionally multiplies by destination weight; jumping ignores weights and can pass nonadjacent jump points. Without an override, DefaultComputeHeuristic uses IDs. C# base._ComputeCost returns default(float), not the native formula. Return a finite nonnegative cost.

public virtual float _EstimateCost(Vector2I fromId, Vector2I endId);

Overrides estimated remaining cost. Optimality requires an admissible consistent heuristic; closed cells are not reopened. For arbitrary nonnegative costs, return 0 is a safe starting estimate for ordinary search. Without an override, DefaultEstimateHeuristic applies; a C# base call returns default(float). Arbitrary custom costs with Jumping require separate validation.