MazeProblem Class Reference

#include <simple_maze.h>

Inheritance diagram for MazeProblem:

Collaboration diagram for MazeProblem:

Public Member Functions
	MazeProblem ()
	~MazeProblem ()
bool	goal_test (State *state) override
	Tests if a given state satisfies the goal condition.
std::vector< std::shared_ptr< Action > >	actions (std::shared_ptr< State > state) override
	Retrieves the set of actions applicable to a given state.
double	heuristic (State *state) override
	Computes a heuristic estimate for a given state.
Public Member Functions inherited from Problem
	Problem ()
	Constructor for the Problem class.
virtual	~Problem ()
	Virtual destructor for the Problem class.
virtual State *	initial_state ()
	Retrieves the initial state of the problem.

Additional Inherited Members
Public Attributes inherited from Problem
State *	initial_state_
	Pointer to the initial state of the problem.

Detailed Description

Definition at line 57 of file simple_maze.h.

Constructor & Destructor Documentation

MazeProblem()

MazeProblem::MazeProblem ( )

inline

Definition at line 59 of file simple_maze.h.

                  {
        initial_state_ = new MazeState();
    }

References Problem::initial_state_.

~MazeProblem()

MazeProblem::~MazeProblem ( )

inline

Definition at line 62 of file simple_maze.h.

                   {
    }

Member Function Documentation

actions()

std::vector< std::shared_ptr< Action > > MazeProblem::actions ( std::shared_ptr< State >  state )

inlineoverridevirtual

Retrieves the set of actions applicable to a given state.

This method must be implemented by the user to define the available actions for a specific state.

Parameters

state

The current state.

Returns

A vector of actions applicable to the given state.

Implements Problem.

Definition at line 69 of file simple_maze.h.

                                                                                  {
        auto maze_state = std::dynamic_pointer_cast<MazeState>(state);
        std::vector<std::shared_ptr<Action>> actions;
 
        auto create_state = [&](int x, int y) {
            return std::make_shared<MazeState>(maze_state->maze, x, y);
        };
 
        // Add possible actions with smart pointers
        if (maze_state->x > 0 && maze_state->maze[maze_state->x - 1][maze_state->y] != 1) {
            actions.push_back(std::make_shared<Action>("Up", 1, state, create_state(maze_state->x - 1, maze_state->y)));
        }
        if (maze_state->x < maze_state->maze.size() - 1 && maze_state->maze[maze_state->x + 1][maze_state->y] != 1) {
            actions.push_back(std::make_shared<Action>("Down", 1, state, create_state(maze_state->x + 1, maze_state->y)));
        }
        if (maze_state->y > 0 && maze_state->maze[maze_state->x][maze_state->y - 1] != 1) {
            actions.push_back(std::make_shared<Action>("Left", 1, state, create_state(maze_state->x, maze_state->y - 1)));
        }
        if (maze_state->y < maze_state->maze[0].size() - 1 && maze_state->maze[maze_state->x][maze_state->y + 1] != 1) {
            actions.push_back(std::make_shared<Action>("Right", 1, state, create_state(maze_state->x, maze_state->y + 1)));
        }
 
        return actions;
    }

References actions().

Referenced by actions().

goal_test()

bool MazeProblem::goal_test ( State *  state )

inlineoverridevirtual

Tests if a given state satisfies the goal condition.

This method must be implemented by the user to define the goal state criteria.

Parameters

state

The state to test.

Returns

True if the state satisfies the goal condition, false otherwise.

Implements Problem.

Definition at line 64 of file simple_maze.h.

                                          {
        auto *maze_state = dynamic_cast<MazeState *>(state);
        return maze_state->maze[maze_state->x][maze_state->y] == -1;
    }

References MazeState::maze.

heuristic()

double MazeProblem::heuristic ( State *  state )

inlineoverridevirtual

Computes a heuristic estimate for a given state.

This method must be implemented by the user to define a heuristic function for the problem.

Parameters

state

The state for which to compute the heuristic.

Returns

A heuristic estimate of the cost to reach the goal from the given state.

Implements Problem.

Definition at line 96 of file simple_maze.h.

                                            {
        auto *maze_state = dynamic_cast<MazeState *>(state);
        return abs(maze_state->x - 3) + abs(maze_state->y - 3);
    }

---

The documentation for this class was generated from the following file:

• include/problems/simple_maze.h