Struct StaticBoardAnalysis 

pub struct StaticBoardAnalysis { /* private fields */ }

Static analysis of game boards (outer walls, corners, play area…)

Static board features are categories of board positions that don’t change semantics even after pushers and boxes had been moved around board. For example:

• positions of outer walls
• position of “corners”
• active playable area
• pusher, box and goal IDs in starting position
• …

This kind of analysis only makes sense when applied to finalized board designs, ie. a GameBoard that is no longer being edited.

Todo

• construct and test more pathological cases for Trioban / Hexoban / Octoban (play area, significant walls, corners, …)
• wall surrounded by walls in play area?
• in Sokoban this wall should not be marked as playable, neither should floors in same position

Implementations

impl StaticBoardAnalysis

pub fn new<I>( board: I, size: Size2D, tessellation: Tessellation, sokoban_plus: Option<&SokobanPlus>, ) -> Result<Self, BoardSyntaxError>

where I: Iterator<Item = TileKind>,

Builds a new StaticBoardAnalysis from a board scan.

That way it is decoupled from GameBoard, with no loss of functionality.

pub fn flood_fill<F>( root: Point2D, is_obstacle: F, size: Size2D, tessellation: Tessellation, ) -> Option<BoardArea>

where F: Fn(Point2D) -> bool,

Flood fill with generic bordering predicate.

None if root is off-board.

Todo

It should probably return top-left position of found area, as an optimization

pub fn size(&self) -> Size2D

Dimensions of the board this analysis was built from.

pub fn tessellation(&self) -> Tessellation

Tessellation of the board this analysis was built from.

pub fn walls_positions(&self) -> &BoardArea

Positions of walls on the board this analysis was built from.

pub fn boxes_positions(&self) -> &BoardArea

Positions of boxes on the board this analysis was built from.

pub fn goals_positions(&self) -> &BoardArea

Positions of goals on the board this analysis was built from.

pub fn pushers_positions(&self) -> &BoardArea

Positions of pushers on the board this analysis was built from.

pub fn boxes(&self) -> &[Boxbox]

See also: GameBoard::boxes()

pub fn goals(&self) -> &[Goal]

See also: GameBoard::goals()

pub fn pushers(&self) -> &[Pusher]

See also: GameBoard::pushers()

pub fn outer_area(&self) -> BoardArea

All board positions that are not part of playable area and are not significant walls.

pub fn playable_area(&self) -> BoardArea

All board positions which are part of “active” board area.

Active board area contains any position that is reachable by any of pushers as if there were no boxes and no other pushers on board.

Any tile not included in this area may be replaced by wall. Resulting GameBoard would no longer look exactly the same but will still have exact same solution.

In following image, greyed out squares are the ones that will not be in set returned by this method:

pub fn is_playable_area_confined(&self) -> bool

Is the playable_area() confined by walls alone?

true when no playable position lies on the board’s outer edge. This is what “closed board” means, and it is the only thing it can mean: flood_fill() stops at walls and at the board edge, so the play area is always confined by walls together with the edge. A board is closed exactly when the edge is not doing any of that work.

A board with no Pusher has no play area at all and is vacuously confined, as is the empty board.

See also: GameBoard::enclose()

pub fn flood_path<F>( from: Point2D, to: Point2D, is_obstacle: F, size: Size2D, tessellation: Tessellation, ) -> Option<Vec<Direction>>

where F: Fn(Point2D) -> bool,

Breadth first search for the shortest path from from to to, with generic bordering predicate.

The path-shaped counterpart of flood_fill(), and deliberately the same shape: both take the obstacle predicate, the board size and the Tessellation as arguments rather than reading them off self, so a caller is free to define “obstacle” however its rules require.

Returns Some empty path when from == to, and None when either endpoint is off-board or to cannot be reached.

pub fn corners(&self) -> BoardArea

Corners in playable area.

pub fn build_box( maybe_id: usize, x: usize, y: usize, sokoban_plus: Option<&SokobanPlus>, ) -> Result<Boxbox, BoardSyntaxError>

Helper for GameBoard scanners. Builds a Boxbox for the maybe_id-th box of a scan, tagged from sokoban_plus.

pub fn build_goal( maybe_id: usize, x: usize, y: usize, sokoban_plus: Option<&SokobanPlus>, ) -> Result<Goal, BoardSyntaxError>

Helper for GameBoard scanners. Builds a Goal for the maybe_id-th goal of a scan, tagged from sokoban_plus.

pub fn build_pusher( maybe_id: usize, x: usize, y: usize, ) -> Result<Pusher, BoardSyntaxError>

Helper for GameBoard scanners. Builds a Pusher for the maybe_id-th pusher of a scan.

pub fn significant_walls(&self) -> BoardArea

All board positions that are touching active playable_area().

In following image, tiles that are not greyed out are positions returned by this method. Notice how it also correctly detects a missing wall tile (circled in red).