maze.h

Go to the documentation of this file.

 
#ifndef MAZE_H // Include guard.
#define MAZE_H
#include <stdint.h>
#include <stdbool.h>
 
// Definitions.
// ----------------------------------------------------------------------------
//
 
#define MAZE_INVERT_BITMASK(x) ((0xFu - x) & 0xFu)
 
// Type definitions.
// ----------------------------------------------------------------------------
//
 
typedef struct maze_point
{
    uint16_t x; 
    uint16_t y; 
} maze_point_t;
 
typedef enum
{
    MAZE_NORTH = 0,  
    MAZE_EAST  = 1,  
    MAZE_SOUTH = 2,  
    MAZE_WEST  = 3,  
    MAZE_NONE  = 255 
} maze_cardinal_direction_t;
 
typedef enum
{
    MAZE_NO_WALLS   = 0, 
    MAZE_FRONT_WALL = 1, 
    MAZE_RIGHT_WALL = 2, 
    MAZE_BACK_WALL  = 4, 
    MAZE_LEFT_WALL  = 8  
} maze_wall_direction_t;
 
typedef enum
{
    MAZE_FRONT, 
    MAZE_RIGHT, 
    MAZE_BACK,  
    MAZE_LEFT   
} maze_relative_direction_t;
 
typedef struct maze_grid_cell
{
    maze_point_t coordinates; 
    uint32_t     f;           
    uint32_t     g; 
    uint32_t h;     
    struct maze_grid_cell *p_next[4]; 
    struct maze_grid_cell
        *p_came_from; 
    bool is_visited;  
} maze_grid_cell_t;
 
typedef struct maze_grid
{
    maze_grid_cell_t *p_grid_array; 
    uint16_t rows;                  
    uint16_t columns;               
} maze_grid_t;
 
typedef struct maze_navigator_state
{
    maze_grid_cell_t *p_current_node; 
    maze_grid_cell_t *p_start_node; 
    maze_grid_cell_t *p_end_node;   
    maze_cardinal_direction_t orientation; 
} maze_navigator_state_t;
 
typedef struct maze_gap_bitmask
{
    uint16_t *p_bitmask; 
    uint16_t rows;       
    uint16_t columns;    
} maze_gap_bitmask_t;
 
typedef union maze_bitmask_compressed
{
    struct
    {
        uint8_t cell_b : 4; 
        uint8_t cell_a : 4; 
    } fields;               
    uint8_t bits;           
} maze_bitmask_compressed_t;
 
// Public Functions.
// ----------------------------------------------------------------------------
//
 
maze_grid_t maze_create(uint16_t rows, uint16_t columns);
 
void maze_initialise_empty_walled(maze_grid_t *p_grid);
 
void maze_clear_heuristics(maze_grid_t *p_grid);
 
void maze_destroy(maze_grid_t *p_grid);
 
int8_t maze_get_nav_dir_offset(const maze_navigator_state_t *p_navigator);
 
void maze_nav_modify_walls(maze_grid_t            *p_grid,
                           maze_navigator_state_t *p_navigator,
                           uint8_t                 aligned_wall_bitmask,
                           bool                    is_set,
                           bool                    is_unset);
 
char *maze_get_string(maze_grid_t *p_grid);
 
void maze_insert_nav_str(const maze_grid_t            *p_grid,
                         const maze_navigator_state_t *p_navigator,
                         char                         *maze_str);
 
maze_cardinal_direction_t maze_get_dir_from_to(const maze_point_t *p_point_a,
                                               const maze_point_t *p_point_b);
 
int16_t maze_deserialise(maze_grid_t        *p_grid,
                         maze_gap_bitmask_t *p_no_walls_array);
 
maze_gap_bitmask_t maze_serialise(maze_grid_t *p_grid);
 
maze_grid_cell_t *maze_get_cell_at_coords(maze_grid_t        *p_grid,
                                          const maze_point_t *p_coordinates);
 
maze_grid_cell_t *maze_get_cell_in_dir(maze_grid_t              *p_grid,
                                       maze_grid_cell_t         *p_from,
                                       maze_cardinal_direction_t direction);
 
uint32_t maze_manhattan_dist(const maze_point_t *p_point_a,
                             const maze_point_t *p_point_b);
 
int16_t maze_serialised_to_buffer(const maze_gap_bitmask_t *p_bitmask,
                                  uint8_t                  *p_buffer,
                                  uint16_t                  buffer_size);
 
int16_t maze_nav_to_buffer(const maze_navigator_state_t *p_navigator,
                           uint8_t                      *p_buffer,
                           uint16_t                      buffer_size);
 
void maze_uint16_to_uint8_buffer(uint16_t value, uint8_t *p_buffer);
 
maze_relative_direction_t maze_get_relative_dir(
    const maze_cardinal_direction_t direction_from,
    const maze_cardinal_direction_t direction_to);
 
#endif // MAZE_H
 
// End of pathfinding/maze.h