Introduction

In this project, your Pacman agent will find paths through his maze world, both to reach a particular location and to collect food efficiently. You will build general search algorithms and apply them to Pacman scenarios.

As in Project 0, this project includes an autograder for you to grade your answers on your machine. This can be run with the command:

python autograder.py

See the autograder tutorial in Project 0 for more information about using the autograder.

The code for this project consists of several Python files, some of which you will need to read and understand in order to complete the assignment, and some of which you can ignore. You can download all of the files for this homework as a zip archive: 1-search.zip. Unzip this file and examine its contents:

Files you'll edit:

• astar_search.py: Where your A* and heuristic implementations (Questions 4-5) will live.

Files you'll want to take a look at:

• search.py: Where the structure of a search problem is defined.
• searchAgents.py: Where all search-based agents are defined.
• util.py: Useful data structures you'll need for defining search algorithms.

Supporting files you can ignore (unless you're curious):

• pacman.py: The main file that runs Pacman games. This file describes a Pacman GameState type, which you use in this project.
• game.py: The logic behind how the Pacman world works. This file describes several supporting types like AgentState, Agent, Direction, and Grid.
• graphicsDisplay.py: Graphics for Pacman
• graphicsUtils.py: Support for Pacman graphics
• textDisplay.py: ASCII graphics for Pacman
• ghostAgents.py: Agents to control ghosts
• keyboardAgents.py: Keyboard interfaces to control Pacman
• layout.py: Code for reading layout files and storing their contents
• autograder.py: Project autograder
• testParser.py: Parses autograder test and solution files
• testClasses.py: General autograding test classes
• test_cases/:Directory containing the test cases for each question
• searchTestClasses.py: Homework 1 specific autograding test classes

Files to Edit and Submit: You will fill in portions of astar_search.py (for Questions 4-5) during the assignment. Submission instructions will be posted soon.

Evaluation: Your code will be autograded for technical correctness. Please do not change the names of any provided functions or classes within the code, or you will wreak havoc on the autograder. However, the correctness of your implementation -- not the autograder's judgements -- will be the final judge of your score. If necessary, I will review and grade assignments individually to ensure that you receive due credit for your work.

Academic Dishonesty: We will be checking your code against other submissions in the class for logical redundancy. If you copy someone else's code and submit it with minor changes, I will know. I trust you all to submit your own work only; please don't let me down. If you do, I will pursue the strongest consequences available to me.

Getting Help: You are not alone! If you find yourself stuck on something, feel free to email me or come to office hours (listed on the course webpage.. Office hours and discussion on Piazza are there for your support; please use them. I want these projects to be rewarding and instructional, not frustrating and demoralizing. But, I don't know when or how to help unless you ask!

Discussion on Piazza: Please be careful not to post spoilers.

Welcome to Pacman

After downloading the code (1-search.zip), unzipping it, and changing to the directory, you should be able to play a game of Pacman by typing the following at the command line:

python pacman.py

Pacman lives in a shiny blue world of twisting corridors and tasty round treats. Navigating this world efficiently will be Pacman's first step in mastering his domain.

The simplest agent in searchAgents.py is called the GoWestAgent, which always goes West (a trivial reflex agent). This agent can occasionally win:

python pacman.py --layout testMaze --pacman GoWestAgent

But, things get ugly for this agent when turning is required:

python pacman.py --layout tinyMaze --pacman GoWestAgent

If Pacman gets stuck, you can exit the game by typing CTRL-c into your terminal.

Soon, your agent will solve not only tinyMaze, but any maze you want.

Note that pacman.py supports a number of options that can each be expressed in a long way (e.g., --layout) or a short way (e.g., -l). You can see the list of all options and their default values via:

python pacman.py -h

Also, all of the commands that appear in this project also appear in commands.txt, for easy copying and pasting. In UNIX/Mac OS X, you can even run all these commands in order with bash commands.txt.

Important Tips

Keep these things in mind while working on your solutions!

• All of your search functions need to return a list of actions that will lead the agent from the start to the goal. These actions all have to be legal moves (valid directions, no moving through walls).
• Make sure to use the Stack, Queue and PriorityQueue data structures provided to you in util.py! These data structure implementations have particular properties which are required for compatibility with the autograder.
• Get familiar with the methods in the SearchProblem class in search.py! You'll need to use these methods as part of your search implementations.
• Remember that lists in Python are passed by reference; if you're seeing actions show up in a list that shouldn't be there, make sure you're copying your actions to a new list every time!
• The autograder is not the final word! It is very possible to correctly implement these algorithms, but have the autograder consider it wrong because you didn't use the right data structures or methods. Final grades will be assigned by examining your implementation, not just using the autograder output.

Question 4 (5 points): A* search

Implement A* graph search in the empty function aStarSearch in astar_search.py. A* takes a heuristic function as an argument. Heuristics take two arguments: a state in the search problem (the main argument), and the problem itself (for reference information). The nullHeuristic heuristic function in astar_search.py is a trivial example.

You can test your A* implementation on the original problem of finding a path through a maze to a fixed position using the Manhattan distance heuristic (implemented already as manhattanHeuristic in astar_search.py).

python pacman.py -l bigMaze -z .5 -p SearchAgent -a fn=astar,heuristic=manhattanHeuristic

You should see that A* finds the optimal solution slightly faster than uniform cost search (about 549 vs. 620 search nodes expanded in my implementation, but ties in priority may make your numbers differ slightly). What happens on openMaze for the various search strategies?

Question 5 (5 points): Eating All The Dots

Note: Make sure to complete Question 4 before working on Question 5, because Question 5 builds upon your answer for Question 4.

Now we'll solve a hard search problem: eating all the Pacman food in as few steps as possible. For this, we'll need a new search problem definition which formalizes the food-clearing problem: FoodSearchProblem in searchAgents.py (implemented for you). A solution is defined to be a path that collects all of the food in the Pacman world. For the present project, solutions do not take into account any ghosts or power pellets; solutions only depend on the placement of walls, regular food and Pacman. (Of course ghosts can ruin the execution of a solution! We'll get to that in the next question.) If you have written your general search methods correctly, A* with a null heuristic (equivalent to uniform-cost search) should quickly find an optimal solution to testSearch with no code change on your part (total cost of 7).

python pacman.py -l testSearch -p AStarFoodSearchAgent

Note: AStarFoodSearchAgent is a shortcut for -p SearchAgent -a fn=astar,prob=FoodSearchProblem,heuristic=foodHeuristic.

You should find that UCS (AStarFoodSearchAgent with the default null heuristic implementation of foodHeuristic) starts to slow down even for the seemingly simple tinySearch. As a reference, my implementation takes about half a second to find a path of length 27 after expanding 5057 search nodes.

Fill in foodHeuristic in astar_search.py with a consistent heuristic for the FoodSearchProblem. Try your agent on the trickySearch board:

python pacman.py -l trickySearch -p AStarFoodSearchAgent

My UCS agent finds the optimal solution in a few seconds, exploring over 16,000 nodes.

Any non-trivial non-negative consistent heuristic will receive 1 point. Make sure that your heuristic returns 0 at every goal state and never returns a negative value. Depending on how few nodes your heuristic expands, you'll get additional points:

Number of nodes expanded	Grade
more than 15000	1/4
at most 15000	2/4
at most 12000	3/4
at most 9000	4/4 (full credit; medium)
at most 7000	5/4 (optional extra credit; hard)

Remember: If your heuristic is inconsistent, you will receive no credit, so be careful! Can you solve mediumSearch in a short time? If so, either (a) I'm very, very impressed, or (b) your heuristic is inconsistent.