Project 3: Ants Vs. SomeBees

Ants vs. Somebees

The bees are coming!
Create a better soldier
With inherit-ants.

Table of Contents

Introduction

In this project, you will create a tower defense defense game called Ants Vs. SomeBees. As the ant queen, you populate your colony with the bravest ants you can muster. Your ants must protect their queen from the evil bees that invade your territory. Irritate the bees enough by throwing leaves at them, and they will be vanquished. Fail to pester the airborne intruders adequately, and your queen will succumb to the bees' wrath. This game is inspired by PopCap Games' Plants Vs. Zombies.

This project combines functional and object-oriented programming paradigms, focusing on the material from Chapter 2.5 of Composing Programs. The project also involves understanding, extending, and testing a large program.

The project includes several files, but you will only modify ants.py. You can download the project code as a zip archive.

ants.py The game logic of Ants Vs. SomeBees.
ants_gui.py Graphics for Ants Vs. SomeBees.
graphics.py General functions for displaying simple two-dimensional animations.
ucb.py Utility functions for CS 61A.
img A directory of images used by the graphical version of the game.
ok Autograder software.
tests A directory of tests used by ok.

Logistics

You'll work in a team of two people, Partner A and Partner B. In each part, you will do some of the work separately and some together with your partner. For example, if a problem is marked 5A, then it is a solo problem for Partner A. Both partners should read, think about, and understand the solution to all questions. Feel free to help each other on the solo questions. If you choose to work on the whole project alone, you must complete all questions yourself.

To submit your finished project, run python3 ok --submit. You can run this command more than once; only the final submission before the deadline will be graded. Only one partner needs to submit. You can specify your partner and view your submissions on the ok website.

Start early! The amount of time it takes to complete a project (or any program) is unpredictable. Ask for help early and often — the TAs and lab assistants are here to help. You are not alone!

Scores will be assigned as follows:

There are also two points of extra credit available at the end of the project, due with your submission.

Core Concepts

A game of Ants Vs. SomeBees consists of a series of turns. In each turn, new bees may enter the ant colony. Then, new ants are placed. Finally, all insects (ants, then bees) take individual actions: bees sting ants, and ants throw leaves at bees. The game ends either when a bee reaches the ant queen (you lose), or the entire bee flotilla has been vanquished (you win).

The Colony. The colony consists of several places that are chained together. The exit of each Place leads to another Place.

Placing Ants. There are two constraints that limit ant production. Placing an ant uses up some amount of the colony's food, a different amount for each type of ant. Also, only one ant can occupy each Place.

Bees. When it is time to act, a bee either moves to the exit of its current Place if no ant blocks its path, or stings an ant that blocks its path.

Ants. Each type of ant takes a different action and requires a different amount of food to place. The two most basic ant types are the HarvesterAnt, which adds one food to the colony during each turn, and the ThrowerAnt, which throws a leaf at a bee each turn.

The Code

Most concepts in the game have a corresponding class that encapsulates the logic for that concept. For instance, a Place in the colony holds insects and connects to other places. A Bee stings ants and advances through exits.

The game can be run in two modes: as a text-based game or using a graphical user interface (GUI). The game logic is the same in either case, but the GUI enforces a turn time limit that makes playing the game more exciting. The text-based interface is provided for debugging and development.

The files are separated according to these two modes. ants.py knows nothing of graphics or turn time limits.

To start a text-based game, run

python3 ants.py

To start a graphical game, run

python3 ants_gui.py

When you start the graphical version, a new window should appear:

In the starter implementation, you have unlimited food and your ants only throw leaves at bees in their current Place. Try playing the game anyway! You'll need to place a lot of ThrowerAnts (the second type) in order to keep the bees from reaching your queen.

The game has several options that you will use throughout the project, which you can view with --help.

usage: ants_gui.py [-h] [-f] [-w] [-i] [--food FOOD]

Play Ants vs. SomeBees

optional arguments:
  -h, --help    show this help message and exit
  -f, --full    loads a full layout and assault plan
  -w, --water   loads a full layout with water
  -i, --insane  loads a difficult assault plan
  --food FOOD   number of food to start with

Testing

We've included an autograder which includes tests for each question. You will have to unlock some of the tests first before you can use them to test your implementations. To unlock tests for question 1, run the following command from your terminal:

python3 ok -u -q 1

Once you have unlocked the tests, you can run the tests for question 1 as follows:

python3 ok -q 1

To help with debugging, you can also start an interactive session whenever an error occurs by adding the -i flag:

python3 ok -q 1 -i

You can also invoke the autograder for all problems at once using:

python3 ok

The tests directory is used to store autograder tests, so make sure not to modify it. You may lose all your unlocking progress if you do. If you need to get a fresh copy, you can download the zip archive and copy it over, but you will need to start unlocking from scratch.

If you have any problems logging in or communicating with the server, use the --local flag to inhibit any server communication.

Phase 1

Problem 1 (0 pts)

Answer the following questions with your partner after you have read the entire ants.py file. If you cannot answer these questions, read the file again or ask a question on Piazza.

  1. What is the significance of an Insect's armor attribute? What happens when armor reaches 0?
  2. What are all of the attributes of the Ant class?
  3. Is the armor attribute of the Ant class an instance attribute or class attribute?
  4. Is the damage attribute of the Ant class an instance attribute or class attribute?
  5. Which class do both Ant and Bee inherit from?
  6. What attribute(s) do Ant and Bee inherit from their superclass?

You can test your understanding by running

python3 ok -u -q 1

Problem 2 (2 pts)

Add food costs and implement harvesters. Currently, there is no cost for deploying any type of Ant, and so there is no challenge to the game. You'll notice that Ant starts out with a base food_cost of zero. Override this value in each of the subclasses listed below with the correct costs.

Class Food Armor

HarvesterAnt		 2 1

ThrowerAnt		 4 1

Now there's no way to gather more food! To fix this issue, implement the HarvesterAnt class. A HarvesterAnt is a type of Ant that adds one food to the colony.food total as its action.

Test your implementation before moving on:

python3 ok -q 2 -u
python3 ok -q 2 -i

Try playing the game again (python3 ants_gui.py). Once you have placed a HarvesterAnt, you should accumulate food each turn. Vanquishing the bees using the default game setup is now possible.

Problem 3 (1 pt)

Add code to the Place constructor that tracks entrances. Right now, a Place keeps track only of its exit. We would like a Place to keep track of its entrance as well. A Place needs to track only one entrance.

However, simply passing an entrance to a Place constructor will be problematic; we would need to have both the exit and the entrance before creating a Place! (It's a chicken or the egg problem.) To get around this problem, we will keep track of entrances in the following way instead. The Place constructor should specify that:

Test your implementation before moving on:

python3 ok -q 3 -u
python3 ok -q 3 -i

Phase 2: Water and Fire (Partner A)

Problem 4A (2 pts)

Add water to the colony. Currently there are only two types of places, the Hive and a basic Place. To make things more interesting, we're going to create a new type of Place called Water.

Only an ant that is watersafe can be deployed to a Water place. In order to determine whether an Insect is watersafe, add a new attribute to the Insect class named watersafe that is False by default. Since bees can fly, make their watersafe attribute True, overriding the default.

Now, implement the add_insect method for Water. First call Place.add_insect to add the insect, regardless of whether it is watersafe. Then, if the insect is not watersafe, reduce the insect's armor to 0 by invoking reduce_armor. Try not to copy and paste code. Instead, use methods that have already been defined and make use of inheritance to reuse the functionality of the Place class.

Test your implementation before moving on:

python3 ok -q 4A -u
python3 ok -q 4A -i

Once you've finished this problem, play a game that includes water. To access the wet_layout that includes water, add the --water option (or -w for short) when you start the game.

python3 ants_gui.py --water

Problem 5A (3 pts)

Implement the FireAnt. A FireAnt has a special reduce_armor method: when the FireAnt's armor reaches zero or lower, it will reduce the armor of all Bees in the same Place as the FireAnt by its damage attribute (defaults to 3).

Class Food Armor

FireAnt		 4 1

Hint: Damaging a bee may cause it to be removed from its place. If you iterate over a list, but change the contents of that list at the same time, you may not visit all the elements. As the Python tutorial suggests, "If you need to modify the list you are iterating over, you must iterate over a copy." You can copy a list by calling the list constructor or slicing the list from the beginning to the end.

Once you've finished implementing the FireAnt, give it a class attribute implemented with the value True. This attribute tells the game that you've added a new type of Ant.

Test your implementation before moving on:

python3 ok -q 5A -u
python3 ok -q 5A -i

After implementing FireAnt, be sure to test your program by playing a game or two! A FireAnt should destroy all co-located Bees when it is stung. To start a game with ten food (for easy testing):

python3 ants_gui.py --food 10

Phase 2: Extended Range (Partner B)

Problem 4B (2 pts)

Implement the nearest_bee method for the ThrowerAnt class. In order for a ThrowerAnt to attack, it must know which bee it should hit. The provided implementation will only hit bees in the same Place. Your job is to fix it so that a ThrowerAnt will throw_at the nearest bee in front of it that is not still in the Hive.

The nearest_bee method returns a random Bee from the nearest place that contains bees. Places are inspected in order by following their entrance attributes.

Hint: The random_or_none function provided in ants.py returns a random element of a sequence.

Test your implementation before moving on:

python3 ok -q 4B -u
python3 ok -q 4B -i

After implementing nearest_bee, a ThrowerAnt should be able to throw_at a Bee in front of it that is not still in the Hive. Make sure that your ants do the right thing! To start a game with ten food (for easy testing):

python3 ants_gui.py --food 10

Problem 5B (3 pts)

Now that the ThrowerAnt has been completed, implement two subclasses of ThrowerAnt.

Neither of these specialized throwers can throw_at a Bee that is exactly 3 Places away. Placing a single one of these (and no other ants) should never win a default game.

Class Food Armor

ShortThrower		 3 1

LongThrower		 3 1

To implement these behaviors, modify the nearest_bee method to reference min_range and max_range attributes, and only return a bee that is in range.

For the base class, ThrowerAnt, set min_range to 0 and max_range to 10. Then, implement the subclasses LongThrower and ShortThrower with appropriately constrained ranges and correct food costs.

Set the implemented class attribute of LongThrower and ShortThrower to True.

Test your implementation before moving on:

python3 ok -q 5B -u
python3 ok -q 5B -i

Phase 3: Seen and Unseen (Partner A)

With your Phase 2 ants, try python3 ants_gui.py --full to play against a full swarm of bees in a multi-tunnel layout and try --insane if you want a real challenge! If the bees are too numerous to vanquish, you might need to create some new ants.

Problem 6A (1 pt)

We are going to add some protection to our glorious AntColony by implementing the WallAnt, which is an ant that does nothing each turn. A WallAnt is useful because it has a large armor value.

Class Food Armor

WallAnt		 4 4

Unlike with previous ants, we have not provided you with a class header. Implement the WallAnt class from scratch. Give it a class attribute name with the value 'Wall' (so that the graphics work) and a class attribute implemented with the value True (so that you can use it in a game).

Test your implementation before moving on:

python3 ok -q 6A -u
python3 ok -q 6A -i

Problem 7A (3 pts)

Implement the NinjaAnt, which damages all Bees that pass by, but can never be stung.

Class Food Armor

NinjaAnt		 6 1

A NinjaAnt does not block the path of a Bee that flies by, and so it is never stung. To implement this behavior, first modify the Ant class to include a new class attribute blocks_path that is True by default. Set the value of blocks_path to False in the NinjaAnt class.

Second, modify the Bee's method blocked to return False if either there is no Ant in the Bee's place or if there is an Ant, but its blocks_path attribute is False. Now Bees will just fly past NinjaAnts.

Finally, we want to make the NinjaAnt damage all Bee's that fly past. Implement the action method in NinjaAnt to reduce the armor of all Bees in the same place as the NinjaAnt by its damage attribute.

Test your implementation before moving on:

python3 ok -q 7A -u
python3 ok -q 7A -i

For a challenge, try to win a game using only HarversterAnt and NinjaAnt.

Phase 3: By Land and Sea (Partner B)

Problem 6B (1 pt)

Currently there are no ants that can be placed on Water. Implement the ScubaThrower, which is a subclass of ThrowerAnt that is more costly and watersafe, but otherwise identical to its base class. A ScubaAnt should not lose its armor when placed in Water.

Class Food Armor

ScubaThrower		 5 1

Unlike with previous ants, we have not provided you with a class header. Implement the ScubaThrower class from scratch. Give it a class attribute name with the value 'Scuba' (so that the graphics work) and a class attribute implemented with the value True (so that you can use it in a game).

Test your implementation before moving on:

python3 ok -q 6B -u
python3 ok -q 6B -i

Problem 7B (3 pts)

We will now implement the new offensive unit called the HungryAnt, which will select a random Bee from its place and eat it whole. After eating a Bee, it must spend 3 turns digesting before eating again.

Class Food Armor

HungryAnt		 4 1

To implement, give HungryAnt a time_to_digest class attribute that holds the number of turns that it takes a HungryAnt to digest (default to 3). Also, give each HungryAnt an instance attribute digesting that counts the number of turns it has left to digest (default is 0, since it hasn't eaten anything at the beginning).

Now we implement the action method of the HungryAnt to check if it's digesting; if so, decrement its digesting counter. Otherwise, eat a random Bee in its place by reducing the Bee's armor to 0 and restarting the digesting timer.

Test your implementation before moving on:

python3 ok -q 78 -u
python3 ok -q 7B -i

Phase 4

Problem 8 (5 pts)

Right now, our ants are quite frail. We'd like to provide a way to help them last longer against the onslaught of the bees. Enter the BodyguardAnt.

Class Food Armor

BodyguardAnt		 4 2

A BodyguardAnt differs from a normal Ant because it can occupy the same Place as another ant. When a BodyguardAnt is added to the same Place as another ant, it shields the other ant and protects it from damage. Attacks should damage the BodyguardAnt first and only hurt the protected ant after the BodyguardAnt has run out of armor.

A BodyguardAnt has an instance attribute ant that stores the ant contained within the bodyguard. It should start off as None, indicating that no ant is currently being protected. Give BodyguardAnt a contain_ant method that takes an Ant argument and sets the ant instance attribute to that argument.

Now, change your program so that a BodyguardAnt and another Ant can simultaneously occupy the same Place:

  1. Add an Ant.container class attribute that indicates whether an ant can contain another. For all Ants except BodyguardAnt, container should be False. The BodyguardAnt.container attribute should be True.

  2. We also need to give Ants a new method, can_contain, that takes an other ant as an argument and returns True if and only if:

    1. This ant is a container.
    2. This ant does not already contain another ant.
    3. The other ant is not a container.

  3. Right now, if we attempt to put a second ant in a Place, the add_insect method of the Place class will immediately cause an error. Change add_insect so that the Place contains the container ant and the container ant contains the other ant:

Almost done! Just a few more things to do.

  1. If a BodyguardAnt containing another ant is removed, then the ant it is containing should be placed where the BodyguardAnt used to be. Update the remove_insect method in the Place class accordingly.
  2. The last step is to make sure that ants that are contained by BodyguardAnts still perform their action. Override the action method for BodyguardAnt accordingly.

Test your implementation before moving on:

python3 ok -q 8 -u
python3 ok -q 8 -i

Problem 9 (5 pts)

Implement the QueenAnt. The queen is a waterproof ScubaThrower that inspires her fellow ants through her bravery. Whenever the queen throws a leaf, she also doubles the damage of all other ants in the same tunnel with her, including any ants protected by a bodyguard. Once any ant's damage has doubled, it cannot be doubled again.

Class Food Armor

QueenAnt		 6 1

However, with great power comes great responsibility. The Queen is governed by three special rules:

  1. If a bee ever enters the place occupied by the queen, then the bees immediately win the game. The game ends even if the queen is protected by a bodyguard. The bees also win if any bee reaches the end of a tunnel where the queen normally would reside.

    In AntColony.simulate, the bees win the game whenever len(self.queen.bees) > 0, where self is the ant colony. Normally, the queen attribute of an AntColony is an instance of a Place. As part of the action of a QueenAnt, the colony.queen should be replaced by a new object, a QueenPlace. A QueenPlace has a bees property method that evaluates to the list of all bees that are either in the original colony.queen location or the place of the QueenAnt.

    You should not have to change the implementation of AntColony.simulate or manipulate the location of bees in any special way. You may assume that a colony.queen attribute will be used for only one purpose: to check whether len(self.queen.bees) > 0. Thus, a QueenPlace instance does not need to support other Place methods, such as add_insect.

  2. There can be only one true queen. Any queen beyond the first one is an impostor and should have its armor reduced to 0 upon taking its first action, without doubling any ant's damage or throwing anything. Impostor queens should not affect the colony's queen attribute. You can detect impostor queens by counting the number of times that an instance of a QueenAnt has been constructed, using a class attribute. Any QueenAnt beyond the first one created is an impostor. You should not have to search through the colony places to find other queens.
  3. The true (first) queen cannot be removed. Attempts to remove the queen should have no effect (but should not cause an error). You will need to modify the remove_insect method of Place to enforce this condition.

Some suggestions:

Test your implementation before moving on:

python3 ok -q 9 -u
python3 ok -q 9 -i

Extra Credit (2 pts)

Implement two final thrower ants that do no damage, but instead replace the action method of a Bee instance that they throw_at with a new method that alters the Bee's behavior for some duration.

We will be implementing two new ants that subclass ThrowerAnt.

Class Food Armor

SlowThrower		 4 1

StunThrower		 6 1

In order to complete the implementations of these two ants, you will need to set their class attributes appropriately and implement the following three functions:

  1. make_slow takes an action method and returns a new action method which performs the original action on turns where colony.time is even and does nothing on other turns.
  2. make_stun takes an action method and returns a new action method which does nothing.
  3. apply_effect takes an effect (either make_slow or make_stun), a bee, and a duration. It then replaces the bee's action with a new action method that will call the affected action for duration turns and then will go back to calling the original action every turn.

You can run some provided tests, but they are not exhaustive:

python3 ok -q EC -u
python3 ok -q EC -i

Make sure to test your code! Your code should be able to apply multiple effects on a target (each new effect applies on top of whatever action method the bee already has at that point, and the target returns to the previous action when the new one runs out).

You are now done with the project! If you weren't able to vanquish the bees' insane-mode assault plan before, do your new ants help? Add some water or design your own layout to keep things interesting.

Feel free to design additional ants, layouts, and assault plans and post them to Piazza.

Acknowledgments: Tom Magrino and Eric Tzeng developed this project with John DeNero. Jessica Wan contributed the artwork. Joy Jeng and Mark Miyashita invented the queen ant. Many others have contributed to the project as well!