Simplify the exercise

This commit is contained in:
Patricia Aas 2021-10-04 13:27:29 +02:00
parent 4461bc5936
commit 84efe184f8

View file

@ -1,59 +1,44 @@
# Functions and Parameter Passing
# 131. Functions and Parameter Passing
In this exercise we will write some helper functions for the game board.
The game board is defined in the `Board.cpp` file and the exported functions are described in `Board.hpp`
The file [`Board.cpp`](../../lib/Board.cpp) defines functions to manipulate the game Board, for example finding where
the walls and the portals are.
## Board.cpp/hpp
## Board.cpp
The structure of these files is as follows. The `cpp` file starts with including the `Board.hpp` file and all of its
contents. Then we open a namespace and define how many rows and columns the board will have. We also create an enum that
defines what each cell value means on the board itself.
The Board itself is represented in memory as a 2 dimensional array. A cell in this grid can be for example walkable, a
wall, a pellet, a super pellet or a portal.
Then we have the actual board. A two dimensional array of integers. This will be the layout of the game board. We use
integers and not the Cell enum we defined above so we can use the numbers directly, the `enum class` is strongly typed,
you can see this when we check for values.
`Cell` is an enum representing the different types of cells.
Below the board are the helper functions. Some of them are static (only visible within this file) and some are not,
those that are not should have a similar function description in the `Board.hpp` file. For example:
`isWalkableForGhost` and `isWalkableForPacMan` are two functions which need to check whether a cell is a wall.
```cpp
// Board.hpp
bool isWalkableForPacMan(GridPosition point);
// Board.cpp
bool isWalkableForPacMan(GridPosition point) {
return cellAtPosition(point) != Cell::wall && cellAtPosition(point) != Cell::pen;
return cellAtPosition(point) != Cell::wall && cellAtPosition(point) != Cell::pen;
}
bool isWalkableForGhost(GridPosition point, GridPosition origin, bool isEyes) {
const Cell cell = cellAtPosition(point);
if (cell == Cell::wall)
return false;
return isEyes || isInPen(origin) || !isInPen(point);
}
```
## Board Unit Tests
The game board is covered by unit tests. They are located in the `testBoard.cpp` file within the `test` directory. They
don't check every single tile on the board but they do assume that the board shape is not changed significantly. If you
change the board layout you might have to change some of the unit tests to match.
Unit tests are broken down into test cases, in this file it is focused on a test case per function. A `TEST_CASE` takes
two arguments, a test name and a tag. The test name needs to be unique and for the tag we use the section of the game we
are testing. Think of them like functions that are called when testing.
## Exercise
Lets add a simple helper function.
Let's add a simple helper function.
You might notice that `isWalkableForPacMan` and `isWalkableForGhost` both call `cellAtPosition` with a `GridPosition`
variable and check if it is a wall.
variable and check if it is a wall. Maybe we can lift that check into a separate function (call it `isWall`) to avoid
repeating ourselves?
1. Create a function called `isWall` below `cellAtPosition` that returns true if the `GridPosition` variable sent in is
a wall. Remember to also create the same function signature in the `Board.hpp` file so this helper function can be
used elsewhere in the project if needed.
1. Create a function called `isWall` between `cellAtPosition` and `isWalkableForPacMan` that returns true if
the `GridPosition` parameter is a wall. A function needs to be defined before it is called, so the order of functions
is important. Try to define `isWall` after ``isWalkableForPacMan` or before `cellAtPosition`. It does not compile
2. Replace the checks within `isWalkableForPacMan` and `isWalkableForGhost` with your new function.
3. Add a new unit test `TEST_CASE` for your function. Since you already added `isWall` to the `Board.hpp` file it should
be accessible within the `testBoard.cpp` file. Check for a couple of cases, similarly to the `isWalkableForPacMan`
test. Remember since the unit tests are not inside of the `pacman` namespace, we need to append `pacman::` to the
function calls.
4. Compile the project and run the unit tests. They should all be passing and if they are not then check which unit test
is failing and figure out what was causing the issue. If all goes well you can run the game.
3. Check to see that the game still works as expected.