diff --git a/pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts b/pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts
index a5a8dfc..5fe922f 100644
--- a/pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts
+++ b/pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts
@@ -7,90 +7,110 @@ import {Direction} from "./direction";
  * @param board The board the character is on
  * @param character The current position of the character
  * @param steps The number of steps the character can move
+ * @returns {Path[]} An array of paths the character can move to
  */
 export default function findPossiblePositions(board: GameMap, character: Character, steps: number): Path[] {
-  const possiblePositions: Path[] = [];
-  findPossibleRecursive(board, character.position, steps, // TODO sometimes the character steps on the same tile twice
-    character instanceof PacMan, possiblePositions);
-  return possiblePositions;
+  return findPossibleRecursive(board, character.position, steps, character instanceof PacMan);
 }
 
-function findPossibleRecursive(board: GameMap, currentPath: Path, steps: number,
-                               isPacMan: boolean, possibleList: Path[]): void {
+/**
+ * Uses recursion to move through the board and find all the possible positions
+ * @param board The board the character is on
+ * @param path The current path the character is on
+ * @param steps The number of steps the character can move
+ * @param isPacMan True if the character is Pac-Man, false if it is a ghost
+ * @returns {Path[]} An array of paths the character can move to
+ */
+function findPossibleRecursive(board: GameMap, path: Path, steps: number, isPacMan: boolean): Path[] {
 
-  if (isOutsideBoard(currentPath, board.length)) {
+  const paths: Path[] = [];
+  if (isOutsideBoard(path, board.length)) {
     if (isPacMan) {
-      addTeleportationTiles(board, currentPath, steps, isPacMan, possibleList);
+      return addTeleportationTiles(board, path, steps, isPacMan);
     }
-    return;
-  } else if (isWall(board, currentPath)) {
-    return;
-  }
+  } else if (!isWall(board, path)) {
+    if (steps === 0) {
+      paths.push(path);
+    } else {
 
-  if (steps === 0) {
-    pushTileToList(board, currentPath, possibleList);
-  } else {
-
-    steps--;
-    tryMove(board, currentPath, Direction.up, steps, isPacMan, possibleList);
-    tryMove(board, currentPath, Direction.right, steps, isPacMan, possibleList);
-    tryMove(board, currentPath, Direction.down, steps, isPacMan, possibleList);
-    tryMove(board, currentPath, Direction.left, steps, isPacMan, possibleList);
+      steps--;
+      paths.push(...tryMove(board, path, Direction.up, steps, isPacMan));
+      paths.push(...tryMove(board, path, Direction.right, steps, isPacMan));
+      paths.push(...tryMove(board, path, Direction.down, steps, isPacMan));
+      paths.push(...tryMove(board, path, Direction.left, steps, isPacMan));
+    }
   }
+  return paths;
 }
 
-function tryMove(board: GameMap, currentPath: Path, direction: Direction, steps: number, isPacMan: boolean, possibleList: Path[]): void {
+/**
+ * Tries to move the character in the given direction
+ * @param board The board the character is on
+ * @param path The current path the character is on
+ * @param direction The direction to move in
+ * @param steps The number of steps the character can move
+ * @param isPacMan True if the character is Pac-Man, false if it is a ghost
+ * @returns {Path[]} An array of paths the character can move to
+ */
+function tryMove(board: GameMap, path: Path, direction: Direction, steps: number, isPacMan: boolean): Path[] {
 
   function getNewPosition(): Position {
     switch (direction) {
       case Direction.left:
         return {
-          x: currentPath.end.x - 1,
-          y: currentPath.end.y
+          x: path.end.x - 1,
+          y: path.end.y
         };
       case Direction.up:
         return {
-          x: currentPath.end.x,
-          y: currentPath.end.y - 1
+          x: path.end.x,
+          y: path.end.y - 1
         };
       case Direction.right:
         return {
-          x: currentPath.end.x + 1,
-          y: currentPath.end.y
+          x: path.end.x + 1,
+          y: path.end.y
         };
       case Direction.down:
         return {
-          x: currentPath.end.x,
-          y: currentPath.end.y + 1
+          x: path.end.x,
+          y: path.end.y + 1
         };
     }
   }
 
-  if (currentPath.direction !== (direction + 2) % 4) {
-    findPossibleRecursive(board, {
+  if (path.direction !== (direction + 2) % 4) {
+    return findPossibleRecursive(board, {
       end: getNewPosition(), direction: direction
-    }, steps, isPacMan, possibleList);
+    }, steps, isPacMan);
   }
+  return [];
 }
 
-function addTeleportationTiles(board: GameMap, currentPath: Path, steps: number, isPacMan: boolean,
-                               possibleList: Path[]): void {
+/**
+ * Finds all the possible paths when using teleportation tiles
+ * @param board The board the character is on
+ * @param path The current path the character is on
+ * @param steps The number of steps the character can move
+ * @param isPacMan True if the character is Pac-Man, false if it is a ghost
+ */
+function addTeleportationTiles(board: GameMap, path: Path, steps: number, isPacMan: boolean): Path[] {
   const possiblePositions = findTeleportationTiles(board);
+  const paths: Path[] = [];
   for (const pos of possiblePositions) {
-    if (pos.end.x !== Math.max(currentPath.end.x, 0) || pos.end.y !== Math.max(currentPath.end.y, 0)) {
-      findPossibleRecursive(board, pos, steps, isPacMan, possibleList);
+    if (pos.end.x !== Math.max(path.end.x, 0) || pos.end.y !== Math.max(path.end.y, 0)) {
+      paths.push(...findPossibleRecursive(board, pos, steps, isPacMan));
     }
   }
+  return paths;
 }
 
-function pushTileToList(board: GameMap, tile: Path | null, list: Path[]): void {
-  if (tile !== null && !list.find(p => p.end.x === tile.end.x && p.end.y === tile.end.y) &&
-    !isOutsideBoard(tile, board.length) && !isSpawn(board, tile)) {
-    list.push(tile);
-  }
-}
-
-function findTeleportationTiles(board: number[][]): Path[] {
+/**
+ * Finds all the teleportation tiles on the board
+ * @param board The board the character is on
+ * @returns {Path[]} An array of paths containing the teleportation tiles
+ */
+function findTeleportationTiles(board: GameMap): Path[] {
   const possiblePositions: Path[] = [];
   const edge = [0, board.length - 1];
 
@@ -105,19 +125,32 @@ function findTeleportationTiles(board: number[][]): Path[] {
   return possiblePositions;
 }
 
+/**
+ * Pushes a path to the array if the position is not a wall
+ * @param board The board the character is on
+ * @param possiblePositions The array of paths to push to
+ * @param x The x position of the path
+ * @param y The y position of the path
+ */
 function pushPath(board: GameMap, possiblePositions: Path[], x: number, y: number): void {
   if (board[x][y] !== TileType.wall) {
     possiblePositions.push({end: {x, y}, direction: findDirection(x, y, board.length)});
   }
 }
 
-function findDirection(x: number, y: number, length: number): Direction {
+/**
+ * Finds the direction the character will be facing when moving to the given position
+ * @param x The x position of the new position
+ * @param y The y position of the new position
+ * @param boardSize The length of the board
+ */
+function findDirection(x: number, y: number, boardSize: number): Direction {
   let direction: Direction;
   if (x === 0) {
     direction = Direction.right;
   } else if (y === 0) {
     direction = Direction.down;
-  } else if (x === length - 1) {
+  } else if (x === boardSize - 1) {
     direction = Direction.left;
   } else {
     direction = Direction.up;
@@ -125,17 +158,32 @@ function findDirection(x: number, y: number, length: number): Direction {
   return direction;
 }
 
+/**
+ * Checks if the character is outside the board
+ * @param currentPos The current position of the character
+ * @param boardSize The size of the board
+ */
 function isOutsideBoard(currentPos: Path, boardSize: number): boolean {
   const pos = currentPos.end;
   return pos.x < 0 || pos.x >= boardSize || pos.y < 0 || pos.y >= boardSize;
 }
 
+/**
+ * Checks if the character is on a wall
+ * @param board The board the character is on
+ * @param currentPos The current position of the character
+ */
 function isWall(board: GameMap, currentPos: Path): boolean {
   const pos = currentPos.end;
   return board[pos.y][pos.x] === TileType.wall; // Shouldn't work, but it does
 }
 
-function isSpawn(board: GameMap, currentPos: Path): boolean {
+/**
+ * Checks if the character is on a spawn
+ * @param board The board the character is on
+ * @param currentPos The current position of the character
+ */
+function isSpawn(board: GameMap, currentPos: Path): boolean { // TODO check if character is on it's own spawn
   const pos = currentPos.end;
   return board[pos.x][pos.y] === TileType.pacmanSpawn || board[pos.x][pos.y] === TileType.ghostSpawn;
 }
diff --git a/pac-man-board-game/ClientApp/tests/game/possibleMovesAlgorithm.test.ts b/pac-man-board-game/ClientApp/tests/game/possibleMovesAlgorithm.test.ts
index 905b091..3dfc3ea 100644
--- a/pac-man-board-game/ClientApp/tests/game/possibleMovesAlgorithm.test.ts
+++ b/pac-man-board-game/ClientApp/tests/game/possibleMovesAlgorithm.test.ts
@@ -57,6 +57,12 @@ test("Pac-Man rolls six from start, should return six positions", () => {
     {at: {x: 5, y: 10}, direction: Direction.up}));
 });
 
+test("Pac-Man rolls four from position [5,1] (right), should return 11", () => {
+  pacMan.follow({end: {x: 5, y: 1}, direction: Direction.right});
+  const result = possibleMovesAlgorithm(testMap, pacMan, 4);
+  expect(result.length).toBe(11); // TODO a character can't move to a different character's spawn
+});
+
 test("Pac-Man rolls three from position [1,5] (left), should return 5", () => {
   pacMan.follow({end: {x: 1, y: 5}, direction: Direction.left});
   const result = possibleMovesAlgorithm(testMap, pacMan, 3);