PageRenderTime 55ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/3 - Ants/ants.html

https://bitbucket.org/wesleyto/cs61a
HTML | 704 lines | 570 code | 134 blank | 0 comment | 0 complexity | 1a6872922f2aaf81c6f0e4615aad77a1 MD5 | raw file
    

  1. <html>
    2. 

  2. <head>
    3. 

  3. <link href="css/assignments.css" rel="stylesheet" type="text/css">
    4. 

  4. <title>Proj03</title>
    5. 

  5. </head>
    6. 

  6. 

  7. <body>
    8. 

  8. <h2>Project 3: Ants Vs. SomeBees</h2>
    9. 

  9. 

  10. <blockquote>
    11. 

  11.   <center>
    12. 

  12.     <img src="img/ants_vs_bees.png" height="200px" />
    13. 

  13.   </center>
    14. 

  14.   <p><cite><center>The bees are coming!<br>
    15. 

  15.   Create a better soldier<br>
    16. 

  16.   With inherit-ants.</center></cite></p>
    17. 

  17. </blockquote>
    18. 

  18. <h3>Introduction</h3>
    19. 

  19. 

  20. <p>In this project, you will create a <a
    21. 

  21.   href="https://secure.wikimedia.org/wikipedia/en/wiki/Tower_defense">tower
    22. 

  22.   defense</a> game called Ants Vs. SomeBees.  As the ant queen, you populate
    23. 

  23. your colony with the bravest ants you can muster.  Your ants must protect their
    24. 

  24. queen from the evil bees that invade your territory.  Irritate the bees enough
    25. 

  25. by throwing leaves at them, and they will be vanquished.  Fail to pester the
    26. 

  26. airborne intruders adequately, and your queen will succumb to the bees' wrath.
    27. 

  27. This game is inspired by PopCap Games' <a
    28. 

  28.   href="http://www.popcap.com/games/pvz/web">Plants Vs. Zombies</a> &reg;.</p>
    29. 

  29. 

  30. <p>This project combines functional and object-oriented programming paradigms,
    31. 

  31. focusing on the material from Chapter 2.5 of the lecture notes.  The project
    32. 

  32. also involves understanding, extending, and testing a large program with many
    33. 

  33. related parts.</p>
    34. 

  34. 

  35. <p>This project includes several files, but all of your changes will be made to
    36. 

  36. the first two.  You can download all of the project code as a <a
    37. 

  37.   href="proj03.zip">zip archive</a>.</p>
    38. 

  38. 

  39. <table cellpadding="10">
    40. 

  40.   <tr>
    41. 

  41.     <td><code><a href="ants.py.html">ants.py</a></code></td>
    42. 

  42.     <td>The game logic of Ants Vs. SomeBees.</td>
    43. 

  43.   </tr>
    44. 

  44.   <tr>
    45. 

  45.     <td><code><a href="written.txt">written.txt</a></code></td>
    46. 

  46.     <td>A place to answer the written problems in the project.</td>
    47. 

  47.   </tr>
    48. 

  48.   <tr>
    49. 

  49.     <td><code><a href="tests.py.html">tests.py</a></code></td>
    50. 

  50.     <td>A series of <i>unit tests</i> to test various parts of your
    51. 

  51.       project.</td>
    52. 

  52.   </tr>
    53. 

  53.   <tr>
    54. 

  54.     <td><code><a href="ants_gui.py.html">ants_gui.py</a></code></td>
    55. 

  55.     <td>Graphics for Ants Vs. SomeBees.</td>
    56. 

  56.   </tr>
    57. 

  57.   <tr>
    58. 

  58.     <td><code><a href="graphics.py.html">graphics.py</a></code></td>
    59. 

  59.     <td>General functions for displaying simple two-dimensional animations.</td>
    60. 

  60.   </tr>
    61. 

  61.   <tr>
    62. 

  62.     <td><code><a href="ucb.py.html">ucb.py</a></code></td>
    63. 

  63.     <td>Utility functions for 61A.</td>
    64. 

  64.   </tr>
    65. 

  65. </table>
    66. 

  66. 

  67. <h3>Logistics</h3>
    68. 

  68. 

  69. <p>This is a two-week project.  You'll work in a team of two people, person A
    70. 

  70. and person B.  In each part, you will do some of the work separately and some
    71. 

  71. together with your partner.  For example, if a problem is marked A1, then it is
    72. 

  72. a solo problem for person A.  Both partners should read, think about, and
    73. 

  73. understand the solution to all questions.</p>
    74. 

  74. 

  75. <p>Start early!  The amount of time it takes to complete a project (or any
    76. 

  76. program) is unpredictable.  Ask for help early and often -- the TAs and lab
    77. 

  77. assistants are here to help.</p>
    78. 

  78. 

  79. <p>In the end, you and your partner will submit one project.  Person-specific
    80. 

  80. problems are graded individually and do not affect your partner's score.  There
    81. 

  81. are 25 possible points for each person.  If you choose to work alone, you must
    82. 

  82. complete the entire project, including all of the questions posed to both
    83. 

  83. partners.</p>
    84. 

  84. 

  85. <p>The only two files that you are required to submit are 
    86. 

  86. <code><a href="ants.py.html">ants.py</a></code> and <code><a href="written.txt">written.txt</a></code>.  You do not need to
    87. 

  87. modify any other files in order to complete the project.  To submit the project,
    88. 

  88. change to the directory where the files are located and run <code>submit
    89. 

  89.   proj3</code>.</p>
    90. 

  90. 

  91. <p><b>This project is due by 11:59 PM on Tuesday, July 24th.</b></p>
    92. 

  92. 

  93. <h3>Core Concepts</h3>
    94. 

  94. 

  95. <p>A game of Ants Vs. SomeBees consists of a series of turns.  In each turn, new
    96. 

  96. bees may enter the ant colony.  Then, new ants are placed.  Finally, all insects
    97. 

  97. (ants, then bees) take individual actions: bees sting ants, and ants throw
    98. 

  98. leaves at bees.  The game ends either when a bee reaches the ant queen (you
    99. 

  99. lose), or the entire bee flotilla has been vanquished (you win).</p>
    100. 

  100. 

  101. <p><b>The Colony</b>.  The colony consists of several places that are chained
    102. 

  102. together.  The <code>exit</code> of each <code>Place</code> leads to another
    103. 

  103. <code>Place</code>.</p>
    104. 

  104. 

  105. <p><b>Placing Ants</b>.  There are two constraints that limit ant production.
    106. 

  106. Placing an ant uses up some amount of the colony's food, a different amount for
    107. 

  107. each type of ant.  Also, only one ant can occupy each <code>Place</code>.</p>
    108. 

  108. 

  109. <p><b>Bees</b>.  When it is time to act, a bee either moves to the
    110. 

  110. <code>exit</code> of its current <code>Place</code> if no ant blocks its path,
    111. 

  111. or stings an ant that blocks its path.</p>
    112. 

  112. 

  113. <p><b>Ants</b>.  Each type of ant takes a different action and requires a
    114. 

  114. different amount of food to place.  The two most basic ant types are the
    115. 

  115. <code>HarvesterAnt</code>, which adds one food to the colony during each turn,
    116. 

  116. and the <code>ThrowerAnt</code>, which throws a leaf at a bee each turn.</p>
    117. 

  117. 

  118. 

  119. <h3>The Code</h3>
    120. 

  120. 

  121. <p>Most concepts in the game have a corresponding class that encapsulates the
    122. 

  122. logic for that concept.  For instance, a <code>Place</code> in the colony holds
    123. 

  123. insects and connects to other places.  A <code>Bee</code> stings ants and
    124. 

  124. advances through exits.</p>
    125. 

  125. 

  126. <p>The game can be run in two modes: as a text-based game or using a graphical
    127. 

  127. user interface (GUI).  The game logic is the same in either case, but the GUI
    128. 

  128. enforces a turn time limit that makes playing the game more exciting.  The
    129. 

  129. text-based interface is provided for debugging and development.</p>
    130. 

  130. 

  131. <p>The files are separated according to these two modes.  <code><a href="ants.py.html">ants.py</a></code>
    132. 

  132. knows nothing of graphics or turn time limits.  All graphical elements are
    133. 

  133. specified in <code><a href="ants_gui.py.html">ants_gui.py</a></code> and <code><a href="graphics.py.html">graphics.py</a></code>.  It is
    134. 

  134. possible to complete this project without ever reading the graphics files.</p>
    135. 

  135. 

  136. <p>To start a text-based game, run</p>
    137. 

  137. 

  138. <pre>python3 ants.py</pre>
    139. 

  139. 

  140. <p>To start a graphical game, run</p>
    141. 

  141. 

  142. <pre>python3 ants_gui.py</pre>
    143. 

  143. 

  144. <p>When you start the graphical version, a new window should appear:</p>
    145. 

  145. 

  146. <center>
    147. 

  147.   <img src="img/gui_explanation.png" style="border: 1px solid #000;"/>
    148. 

  148. </center>
    149. 

  149. 

  150. <p>In the starter implementation, you have unlimited food and your ants only
    151. 

  151. throw leaves at bees in their current <code>Place</code>.  Try playing a game
    152. 

  152. anyway!  You'll need to place a lot of <code>ThrowerAnt</code>s (the second
    153. 

  153. type) in order to keep the bees from reaching your queen.</p>
    154. 

  154. 

  155. <p>You have also been provided a testing file <code><a href="tests.py.html">tests.py</a></code> that runs a
    156. 

  156. series of unit tests for the project.  To test your project, you can run</p>
    157. 

  157. 

  158. <pre>python3 tests.py -v</pre>
    159. 

  159. 

  160. <p>This command runs all of the unit tests along with any doctests in ants.py.
    161. 

  161. The optional <code>-v</code> generates more verbose output.  If you would like
    162. 

  162. to learn more about Python's built-in unit testing framework, read the
    163. 

  163. documentation on the <a
    164. 

  164.   href="http://docs.python.org/py3k/library/unittest.html">unittest module</a>.
    165. 

  165. Most problems have associated tests.  Make sure that the tests for each problem
    166. 

  166. pass before moving on.</p>
    167. 

  167. 

  168. <h4>UNIX Crash Course</h4>
    169. 

  169. 

  170. <p>Since the unittests generate a lot of output, knowing a few Unix tricks will
    171. 

  171. come in handy.  The complete 
    172. 

  172. <a href="http://www.ee.surrey.ac.uk/Teaching/Unix/index.html">UNIX tutorial</a> 
    173. 

  173. is a really great resource.  For the unittests in this project, 
    174. 

  174. <a href="http://www.ee.surrey.ac.uk/Teaching/Unix/unix3.html">redirection and piping</a> 
    175. 

  175. will be especially useful.</p>
    176. 

  176. 

  177. <p>You can use piping to "page" through the output of the tests:</p>
    178. 

  178. 

  179. <pre>python3 tests.py -v | less</pre>
    180. 

  180. 

  181. <p>This will show one page of the output at a time.  Press the spacebar to view
    182. 

  182. the next page, "d" (down) to scroll down, and "b" (back) to scroll up.  Once
    183. 

  183. you get to the end of the file, you'll exit automatically.  However, you can
    184. 

  184. exit the pager at any time by typing "q" (quit).</p>
    185. 

  185. 

  186. <p>You can also redirect the output into a file to view at your leisure:</p>
    187. 

  187. 

  188. <pre>python3 tests.py -v > file_name</pre>
    189. 

  189. 

  190. <p>Then you can use any text editor you like to view the output of the tests.
    191. 

  191. A word of caution: redirecting overwrites your file.  If you only want to add
    192. 

  192. to your file, use two "arrows."</p>
    193. 

  193. 

  194. <pre>python3 tests.py -v >> file_name</pre>
    195. 

  195. 

  196. <h3>Phase 1</h3>
    197. 

  197. 

  198. <h4>Both Partners</h4>
    199. 

  199. 

  200. <p><b>Problem 1</b> (3 pts).  Answer the following written questions in the file
    201. 

  201. called <code>written.txt</code> after you have read the <i>entire</i>
    202. 

  202. <code><a href="ants.py.html">ants.py</a></code> file.</p>
    203. 

  203. 

  204. <ol>
    205. 

  205.   <li>Which method in which class runs a game? (the answer is not
    206. 

  206.   <code>run</code>, because <code>run</code> is not a method)!</li>
    207. 

  207. 

  208.   <li>The <code>Hive</code>, a subclass of <code>Place</code>, is the starting
    209. 

  209.   location of the bees.  Unlike most instances of <code>Place</code>, the
    210. 

  210.   <code>Hive</code> class does not have an <code>exit</code>.  Explain how and
    211. 

  211.   when <code>Bee</code>s leave the <code>Hive</code>.</li>
    212. 

  212. 

  213.   <li>Explain the mechanism in the code by which the places in the colony are
    214. 

  214.   laid out.  How do you modify the code to produce more places?</li>
    215. 

  215. 

  216.   <li>What is the significance of an <code>Insect</code>'s <code>armor</code>
    217. 

  217.   attribute?  What happens when <code>armor</code> reaches 0?</li>
    218. 

  218. </ol>
    219. 

  219. 

  220. <p><b>Problem 2</b> (2 pts).  Add food costs and implement harvesters.
    221. 

  221. Currently, there is no cost for deploying any type of <code>Ant</code>, and so
    222. 

  222. there is no challenge to the game.  You'll notice that <code>Ant</code> starts
    223. 

  223. out with a base <code>food_cost</code> of 0.  Override this value in each of the
    224. 

  224. subclasses listed below with the correct costs.</p>
    225. 

  225. 

  226. <table class="ant">
    227. 

  227.   <tr>
    228. 

  228.     <td><b>Class</b></td>
    229. 

  229.     <td><b>Food</b></td>
    230. 

  230.     <td><b>Armor</b></td>
    231. 

  231.   </tr>
    232. 

  232.   <tr>
    233. 

  233.     <td><img src="img/ant_harvester.gif" /> <br> <code>HarvesterAnt</code></td>
    234. 

  234.     <td>2</td>
    235. 

  235.     <td>1</td>
    236. 

  236.   </tr>
    237. 

  237.   <tr>
    238. 

  238.     <td><img src="img/ant_thrower.gif" /> <br> <code>ThrowerAnt</code></td>
    239. 

  239.     <td>4</td>
    240. 

  240.     <td>1</td>
    241. 

  241.   </td>
    242. 

  242. </table>
    243. 

  243. 

  244. <p>Now there's no way to gather more food!  To fix this issue, implement the
    245. 

  245. <code>HarvesterAnt</code> class.  A <code>HarvesterAnt</code> is a type of
    246. 

  246. <code>Ant</code> that adds one food to the <code>colony.food</code> total as its
    247. 

  247. <code>action</code>.</p>
    248. 

  248. 

  249. <p>Try playing the game again.  Once you have placed a
    250. 

  250. <code>HarvesterAnt</code>, you should accumulate food each turn.  Vanquishing
    251. 

  251. the bees using the default game setup is now possible, but should be
    252. 

  252. challenging.</p>
    253. 

  253. 

  254. <p><b>Problem 3</b> (2 pts).  Add code to the <code>Place</code> constructor
    255. 

  255. that tracks entrances.  Right now, a <code>Place</code> keeps track only of its
    256. 

  256. <code>exit</code>.  We would like a <code>Place</code> to keep track of its
    257. 

  257. entrance as well.  A <code>Place</code> needs to track only one
    258. 

  258. <code>entrance</code>.</p>
    259. 

  259. 

  260. <p>However, simply passing an entrance to a <code>Place</code> constructor will
    261. 

  261. be problematic; we will need to have both the exit and the entrance before we
    262. 

  262. can create a <code>Place</code>! (It's a <a
    263. 

  263.   href="https://secure.wikimedia.org/wikipedia/en/wiki/Chicken_or_the_egg">chicken
    264. 

  264.   or the egg</a> problem.) To get around this problem, we will keep track of
    265. 

  265. entrances in the following way instead.  The <code>Place</code> constructor
    266. 

  266. should specify that:</p>
    267. 

  267. 

  268. <ul>
    269. 

  269.   <li>A newly created <code>Place</code> always starts with its
    270. 

  270.   <code>entrance</code> as <code>None</code>.</li>
    271. 

  271. 

  272.   <li>If the <code>Place</code> has an <code>exit</code>, then the
    273. 

  273.   <code>exit</code>'s <code>entrance</code> is set to that
    274. 

  274.   <code>Place</code>.</li>
    275. 

  275. </ul>
    276. 

  276. 

  277. 

  278. <h4>Person A</h4>
    279. 

  279. 

  280. <p><b>Problem A4</b> (2 pts).  Add water to the colony.  Currently there are
    281. 

  281. only two types of places, the <code>Hive</code> and a basic <code>Place</code>.
    282. 

  282. To make things more interesting, we're going to create a new type of
    283. 

  283. <code>Place</code> called <code>Water</code>.</p>
    284. 

  284. 

  285. <p>Only an ant that is <code>watersafe</code> can be deployed to a
    286. 

  286. <code>Water</code> place.  In order to determine whether an <code>Insect</code>
    287. 

  287. is <code>watersafe</code>, add a new attribute to the <code>Insect</code> class
    288. 

  288. named <code>watersafe</code> that is <code>False</code> by default.  Since bees
    289. 

  289. can fly, make their <code>watersafe</code> attribute <code>True</code>,
    290. 

  290. overriding the default.</p>
    291. 

  291. 

  292. <p>Now, implement the <code>add_insect</code> method for <code>Water</code>
    293. 

  293. that,  in addition to doing the same thing as a <code>Place</code> would do,
    294. 

  294. immediately kills the added insect if it is not <code>watersafe</code> by
    295. 

  295. modifying the <code>Insect</code>'s <code>armor</code>.  <b>Do not</b> copy and
    296. 

  296. paste code.  Try to use methods that have already been defined and make use of 
    297. 

  297. inheritance to reuse the functionality of the <code>Place</code> class.</p>
    298. 

  298. 

  299. <p>Once you've finished this problem, play a game that includes water.  To
    300. 

  300. access the <code>mixed_layout</code> that includes water, add the
    301. 

  301. <code>--water</code> option (or <code>-w</code> for short) when you start the
    302. 

  302. game.</p>
    303. 

  303. 

  304. <pre>python3 ants_gui.py --water</pre>
    305. 

  305. 

  306. 

  307. <p><b>Problem A5</b> (3 pts).  Implement the <code>FireAnt</code>.  A
    308. 

  308. <code>FireAnt</code> has a special <code>reduce_armor</code> method that, when
    309. 

  309. the <code>FireAnt</code>'s armor reaches zero or lower, will reduce the armor of
    310. 

  310. <i>all</i> <code>Bee</code>s in the same <code>Place</code> as the
    311. 

  311. <code>FireAnt</code> by <code>3</code> (a fiery end indeed).</p>
    312. 

  312. 

  313. <table class="ant">
    314. 

  314.   <tr>
    315. 

  315.     <td><b>Class</b></td>
    316. 

  316.     <td><b>Food</b></td>
    317. 

  317.     <td><b>Armor</b></td>
    318. 

  318.   </tr>
    319. 

  319.   <tr>
    320. 

  320.     <td><img src="img/ant_fire.gif" /> <br> <code>FireAnt</code></td>
    321. 

  321.     <td>4</td>
    322. 

  322.     <td>1</td>
    323. 

  323.   </td>
    324. 

  324. </table>
    325. 

  325. 

  326. <p><i>Hint:</i> If you iterate over a list, but change the contents of that list
    327. 

  327. at the same time, you may not see all the elements.  As the <a
    328. 

  328.   href="http://docs.python.org/py3k/tutorial/controlflow.html#for-statements">Python
    329. 

  329.   tutorial</a> suggests, "If you need to modify the list you are iterating over,
    330. 

  330. you must iterate over a copy." Remember that damaging a bee may cause it to be
    331. 

  331. removed from its place.</p>
    332. 

  332. 

  333. <p>Once you've finished implementing the <code>FireAnt</code>, give it an
    334. 

  334. instance attribute <code>implemented</code> with the value <code>True</code>.
    335. 

  335. This attribute tells the game that you've added a new type of
    336. 

  336. <code>Ant</code>.</p>
    337. 

  337. 

  338. <p>After implementing <code>FireAnt</code>, be sure to test your program by
    339. 

  339. playing a game or two!  A <code>FireAnt</code> should destroy any co-located
    340. 

  340. Bees when it dies.</p>
    341. 

  341. 

  342. 

  343. <h4>Person B</h4>
    344. 

  344. 

  345. <p><b>Problem B4</b> (2 pts).  Implement the <code>nearest_bee</code> method for
    346. 

  346. the <code>ThrowerAnt</code> class.  In order for a <code>ThrowerAnt</code> to
    347. 

  347. attack, it must know which bee it should hit.  The provided implementation will
    348. 

  348. only hit bees in the same <code>Place</code>.  Your job is to fix it so that a
    349. 

  349. <code>ThrowerAnt</code> will <code>throw_at</code> the nearest bee in front of
    350. 

  350. it that is not still in the <code>Hive</code>.</p>
    351. 

  351. 

  352. <p>The <code>nearest_bee</code> method returns a random <code>Bee</code> from
    353. 

  353. the nearest place that contains bees.  Places are inspected in order by
    354. 

  354. following their <code>entrance</code> attributes.</p>
    355. 

  355. 

  356. <ul>
    357. 

  357.   <li>Start from the current <code>Place</code> of the
    358. 

  358.   <code>ThrowerAnt</code>.</li>
    359. 

  359. 

  360.   <li>For each place, return a random bee if there is any, or consider the next
    361. 

  361.   place that is stored as the current place's <code>entrance</code>.</li>
    362. 

  362. </ul>
    363. 

  363. 

  364. <p>After implementing <code>nearest_bee</code>, a <code>ThrowerAnt</code> should
    365. 

  365. be able to <code>throw_at</code> a <code>Bee</code> in front of it that is not
    366. 

  366. still in the <code>Hive</code>.  Make sure that your ants do the right
    367. 

  367. thing!</p>
    368. 

  368. 

  369. <p><b>Problem B5</b> (3 pts).  Now that the <code>ThrowerAnt</code> has been
    370. 

  370. completed, implement two subclasses of <code>ThrowerAnt</code>.</p>
    371. 

  371. 

  372. <ul>
    373. 

  373.   <li>The <code>LongThrower</code> can only <code>throw_at</code> a
    374. 

  374.   <code>Bee</code> that is found after following at least 4
    375. 

  375.   <code>entrance</code> transitions.  So the <code>LongThrower</code> can't hit
    376. 

  376.   <code>Bee</code>s that are in the same <code>Place</code> as it or the first 3
    377. 

  377.   <code>Place</code>s in front of it.</li>
    378. 

  378. 

  379.   <li>The <code>ShortThrower</code> can only <code>throw_at</code> a
    380. 

  380.   <code>Bee</code> that is found after following at most 2 <code>entrance</code>
    381. 

  381.   transitions.  So the <code>ShortThrower</code> can only hit <code>Bee</code>s
    382. 

  382.   in the same <code>Place</code> as it and 2 <code>Place</code>s in front of
    383. 

  383.   it.</li>
    384. 

  384. </ul>
    385. 

  385. 

  386. <p>Neither of these specialized throwers can <code>throw_at</code> a
    387. 

  387. <code>Bee</code> that is exactly 3 <code>Place</code>s away.  Placing a single
    388. 

  388. one of these (and no other ants) should never win a default game.</p>
    389. 

  389. 

  390. <table class="ant">
    391. 

  391.   <tr>
    392. 

  392.     <td><b>Class</b></td>
    393. 

  393.     <td><b>Food</b></td>
    394. 

  394.     <td><b>Armor</b></td>
    395. 

  395.   </tr>
    396. 

  396.   <tr>
    397. 

  397.     <td><img src="img/ant_shortthrower.gif" /> <br>
    398. 

  398.       <code>ShortThrower</code></td>
    399. 

  399.     <td>3</td>
    400. 

  400.     <td>1</td>
    401. 

  401.   </tr>
    402. 

  402.   <tr>
    403. 

  403.     <td><img src="img/ant_longthrower.gif" /> <br> <code>LongThrower</code></td>
    404. 

  404.     <td>3</td>
    405. 

  405.     <td>1</td>
    406. 

  406.   </tr>
    407. 

  407. </table>
    408. 

  408. 

  409. <p>To implement these behaviors, modify the <code>nearest_bee</code> method to
    410. 

  410. reference <code>min_range</code> and <code>max_range</code> attributes, and only
    411. 

  411. return a bee that is in range.</p>
    412. 

  412. 

  413. <p>For the base class, <code>ThrowerAnt</code>, set <code>min_range</code> to 0
    414. 

  414. and <code>max_range</code> to 10.  Then, implement the subclasses
    415. 

  415. <code>LongThrower</code> and <code>ShortThrower</code> with appropriately
    416. 

  416. constrained ranges and correct food costs.</p>
    417. 

  417. 

  418. <p>Set the <code>implemented</code> class attribute of <code>LongThrower</code>
    419. 

  419. and <code>ShortThrower</code> to <code>True</code>.</p>
    420. 

  420. 

  421. <p>Try playing a game with your newly implemented ants.  Be sure that they do
    422. 

  422. what you expect them to!  You can try running <code><a href="ants_gui.py.html">ants_gui.py</a></code> with the
    423. 

  423. <code>--full</code> option to go up against a full swarm of bees in a
    424. 

  424. multi-tunnel layout, and add <code>--insane</code> if you want a real challenge!
    425. 

  425. If the bees are too numerous to vanquish, you might need to create some new ants
    426. 

  426. in Phase 2.</p>
    427. 

  427. 

  428. 

  429. <h3>Phase 2</h3>
    430. 

  430. 

  431. <h4>Person A</h4>
    432. 

  432. 

  433. <p><b>Problem A6</b> (1 pts).  We are going to add some protection to our
    434. 

  434. glorious <code>AntColony</code> by implementing the <code>WallAnt</code>, which
    435. 

  435. is an ant that does nothing each turn (already the default <code>action</code>
    436. 

  436. of the <code>Ant</code> class).  A <code>WallAnt</code> is useful because it has
    437. 

  437. a large <code>armor</code> value.</p>
    438. 

  438. 

  439. <table class="ant">
    440. 

  440.   <tr>
    441. 

  441.     <td><b>Class</b></td>
    442. 

  442.     <td><b>Food</b></td>
    443. 

  443.     <td><b>Armor</b></td>
    444. 

  444.   </tr>
    445. 

  445.   <tr>
    446. 

  446.     <td><img src="img/ant_wall.gif" /> <br> <code>WallAnt</code></td>
    447. 

  447.     <td>4</td>
    448. 

  448.     <td>4</td>
    449. 

  449.   </td>
    450. 

  450. </table>
    451. 

  451. 

  452. <p><b>Problem A7</b> (3 pts).  Implement the <code>NinjaAnt</code>, which
    453. 

  453. damages all <code>Bee</code>s that pass by, but is never seen.</p>
    454. 

  454. 

  455. <table class="ant"> 
    456. 

  456.   <tr>
    457. 

  457.     <td><b>Class</b></td>
    458. 

  458.     <td><b>Food</b></td>
    459. 

  459.     <td><b>Armor</b></td>
    460. 

  460.   </tr>
    461. 

  461.   <tr>
    462. 

  462.     <td><img src="img/ant_ninja.gif" /> <br> <code>NinjaAnt</code></td>
    463. 

  463.     <td>6</td>
    464. 

  464.     <td>1</td>
    465. 

  465.   </td>
    466. 

  466. </table>
    467. 

  467. 

  468. <p>A <code>NinjaAnt</code> is not able to be attacked by a <code>Bee</code>
    469. 

  469. because it is hidden, nor does it block the path of a <code>Bee</code> that
    470. 

  470. flies by.  To implement this behavior, first modify the <code>Ant</code> class
    471. 

  471. to include a new class attribute <code>blocks_path</code> that is
    472. 

  472. <code>True</code> by default.  Set the value of <code>blocks_path</code> to
    473. 

  473. <code>False</code> in the <code>NinjaAnt</code> class.</p>
    474. 

  474. 

  475. <p>Second, modify the <code>Bee</code>'s method <code>blocked</code> to return
    476. 

  476. <code>False</code> if either there is no <code>Ant</code> in the
    477. 

  477. <code>Bee</code>'s <code>place</code> or if there is an <code>Ant</code>, but
    478. 

  478. its <code>blocks_path</code> attribute is <code>False</code>.  Now
    479. 

  479. <code>Bee</code>s will just fly past <code>NinjaAnt</code>s.</p>
    480. 

  480. 

  481. <p>Finally, we want to make the <code>NinjaAnt</code> damage all
    482. 

  482. <code>Bee</code>'s that fly past.  Implement the <code>action</code> method in
    483. 

  483. <code>NinjaAnt</code> to reduce the armor of all <code>Bee</code>s in the same
    484. 

  484. <code>place</code> as the <code>NinjaAnt</code> by 1, overriding the default
    485. 

  485. action method inherited from <code>Ant</code>.</p>
    486. 

  486. 

  487. <p>For a challenge, try to win a default game using only
    488. 

  488. <code>HarversterAnt</code> and <code>NinjaAnt</code>.</p>
    489. 

  489. 

  490. <h4>Person B</h4>
    491. 

  491. 

  492. <p><b>Problem B6</b> (1 pts).  Currently there are no ants that can be placed on
    493. 

  493. <code>Water</code>.  Implement the <code>ScubaThrower</code>, which is a
    494. 

  494. subclass of <code>ThrowerAnt</code> that is more costly and
    495. 

  495. <code>watersafe</code>, but otherwise identical to its base class.</p>
    496. 

  496. 

  497. <table class="ant">
    498. 

  498.   <tr>
    499. 

  499.     <td><b>Class</b></td>
    500. 

  500.     <td><b>Food</b></td>
    501. 

  501.     <td><b>Armor</b></td>
    502. 

  502.   </tr>
    503. 

  503.   <tr>
    504. 

  504.     <td><img src="img/ant_scuba.gif" /> <br> <code>ScubaThrower</code></td>
    505. 

  505.     <td>5</td>
    506. 

  506.     <td>1</td>
    507. 

  507.   </tr>
    508. 

  508. </table>
    509. 

  509. 

  510. <p>Placing a <code>ScubaAnt</code> in <code>Water</code> should not cause it to
    511. 

  511. die.</p>
    512. 

  512. 

  513. <p><b>Problem B7</b> (3 pts).  We will now implement the new offensive unit
    514. 

  514. called the <code>HungryAnt</code>, which will eat a random <code>Bee</code> from
    515. 

  515. its <code>place</code>, instantly killing the <code>Bee</code>.  After eating a
    516. 

  516. <code>Bee</code>, it must spend 3 turns digesting before eating again.</p>
    517. 

  517. 

  518. <table class="ant">
    519. 

  519.   <tr>
    520. 

  520.     <td><b>Class</b></td>
    521. 

  521.     <td><b>Food</b></td>
    522. 

  522.     <td><b>Armor</b></td>
    523. 

  523.   </tr>
    524. 

  524.   <tr>
    525. 

  525.     <td><img src="img/ant_hungry.gif" /> <br> <code>HungryAnt</code></td>
    526. 

  526.     <td>4</td>
    527. 

  527.     <td>1</td>
    528. 

  528.   </td>
    529. 

  529. </table>
    530. 

  530. 

  531. <p>To implement, give <code>HungryAnt</code> a <code>time_to_digest</code> class
    532. 

  532. attribute that holds the number of turns that it takes all
    533. 

  533. <code>HungryAnt</code>s to digest (default to 3).  Also, give each
    534. 

  534. <code>HungryAnt</code> an instance attribute <code>digesting</code> that counts
    535. 

  535. the number of turns it has left to digest (default is 0, since it hasn't eaten
    536. 

  536. anything at the beginning).</p>
    537. 

  537. 

  538. <p>Now we implement the <code>action</code> method of the <code>HungryAnt</code>
    539. 

  539. to check if it's digesting; if so, decrement its <code>digesting</code> counter.
    540. 

  540. Otherwise, eat a random <code>Bee</code> in its <code>place</code> (killing the
    541. 

  541. <code>Bee</code> and restarting the <code>digesting</code> timer).</p>
    542. 

  542. 

  543. <h4>Both Partners</h4>
    544. 

  544. 

  545. <p><b>Problem 8</b> (5 pts).  Implement the <code>BushAnt</code>.  Right now,
    546. 

  546. our ants are quite frail.  We'd like to provide a way to help them last longer
    547. 

  547. against the onslaught of the bees.  Enter the <code>BushAnt</code>.</p>
    548. 

  548. 

  549. <table class="ant">
    550. 

  550.   <tr>
    551. 

  551.     <td><b>Class</b></td>
    552. 

  552.     <td><b>Food</b></td>
    553. 

  553.     <td><b>Armor</b></td>
    554. 

  554.   </tr>
    555. 

  555.   <tr>
    556. 

  556.     <td><img src="img/ant_weeds.gif" /> <br> <code>BushAnt</code></td>
    557. 

  557.     <td>4</td>
    558. 

  558.     <td>2</td>
    559. 

  559.   </tr>
    560. 

  560. </table>
    561. 

  561. 

  562. <p>A <code>BushAnt</code> differs from a normal <code>Ant</code> because it can
    563. 

  563. occupy the same <code>Place</code> as another ant.  When a <code>BushAnt</code>
    564. 

  564. is added to the same <code>Place</code> as another ant, it shields the other ant
    565. 

  565. and protects it from damage.  Attacks should damage the <code>BushAnt</code>
    566. 

  566. first and only hurt the protected ant after the <code>BushAnt</code> has
    567. 

  567. perished.</p>
    568. 

  568. 

  569. <p>A <code>BushAnt</code> has an instance attribute <code>ant</code> that stores
    570. 

  570. the ant contained within the bush.  It should start off as <code>None</code>,
    571. 

  571. indicating that no ant is currently being protected.  Give <code>BushAnt</code>
    572. 

  572. a <code>contain_ant</code> method that takes an <code>Ant</code> argument and
    573. 

  573. sets the <code>ant</code> instance attribute to that argument.</p>
    574. 

  574. 

  575. <p>Now, change your program so that a <code>BushAnt</code> and another
    576. 

  576. <code>Ant</code> can simultaneously occupy the same <code>Place</code>:</p>
    577. 

  577. 

  578. <ol>
    579. 

  579.   <li>Add an <code>Ant.container</code> class attribute that indicates whether
    580. 

  580.   an ant can contain another.  For all <code>Ant</code>s except
    581. 

  581.   <code>BushAnt</code>, <code>container</code> should be <code>False</code>.
    582. 

  582.   The <code>BushAnt.container</code> attribute should be <code>True</code>.</li>
    583. 

  583. 

  584.   <li>We also need to give <code>Ant</code>s a new method,
    585. 

  585.   <code>can_contain</code>, that takes an <code>other</code> ant as an argument
    586. 

  586.   and returns <code>True</code> if and only if: 
    587. 

  587.     <ol>
    588. 

  588.       <li>This ant is a container.</li>
    589. 

  589.       <li>This ant does not already contain another ant.</li>
    590. 

  590.       <li>The other ant is not a container.</li>
    591. 

  591.     </ol>
    592. 

  592.   </li>
    593. 

  593. 

  594.   <li>Right now, if we attempt to put a second ant in a <code>Place</code>, the
    595. 

  595.   <code>add_insect</code> method of the <code>Place</code> class will
    596. 

  596.   immediately cause an error.  Change <code>add_insect</code> so that the
    597. 

  597.   <code>Place</code> contains the container ant and the container ant contains
    598. 

  598.   the other ant:
    599. 

  599.     <ul>
    600. 

  600.       <li>If the <code>Ant</code> currently occupying this <code>Place</code>
    601. 

  601.       can contain the <code>Ant</code> we are trying to add, then simply tell it
    602. 

  602.       to do so.</li>
    603. 

  603.       
    604. 

  604.       <li>If the <code>Ant</code> we are trying to add can contain the
    605. 

  605.       <code>Ant</code> currently occupying this <code>Place</code>, then have it
    606. 

  606.       do so <em>and</em> set this <code>Place</code>'s ant to be the newly added
    607. 

  607.       <code>Ant</code>.</li>
    608. 

  608. 

  609.       <li>If neither <code>Ant</code> can contain the other, then raise the same
    610. 

  610.       assertion error as before.</li>
    611. 

  611.     </ul>
    612. 

  612.   </li>
    613. 

  613. </ol>
    614. 

  614. 

  615. <p>Almost done!  Just a few more things to do.  </p>
    616. 

  616. 

  617. <ol>
    618. 

  618.   <li>When a <code>BushAnt</code> perishes, we need to make sure the ant it 
    619. 

  619.   currently contains (if it contains one) takes the <code>BushAnt</code>'s 
    620. 

  620.   place.  Override the <code>reduce_armor</code> method so that, if the 
    621. 

  621.   <code>BushAnt</code> perishes, it will set its place's ant to be the ant it 
    622. 

  622.   currently contains. (Remember to use inheritance!)</li>
    623. 

  623. 

  624.   <li>The last step is to make sure that ants that are contained by
    625. 

  625.   <code>BushAnt</code>s still perform their action.  Override the
    626. 

  626.   <code>action</code> method for <code>BushAnt</code> accordingly.</li>
    627. 

  627. </ol>
    628. 

  628. 

  629. <p><b>Problem 9</b> (4 pts).  Implement two final thrower ants that do no
    630. 

  630. damage, but instead replace the <code>action</code> method of a <code>Bee</code>
    631. 

  631. instance that they <code>throw_at</code> with a new method that alters the
    632. 

  632. <code>Bee</code>'s behavior for some duration.</p>
    633. 

    634. 

  634. <p>We will be implementing two new ants that subclass <code>ThrowerAnt</code>.</p>
    635. 

  635. 

  636. <ul>
    637. 

  637.   <li><code>SlowThrower</code> applies a slow effect for 3 turns.</li>
    638. 

  638. 

  639.   <li><code>StunThrower</code> applies a stun effect for 1 turn.</li>
    640. 

  640. </ul>
    641. 

  641. 

  642. <table class="ant">
    643. 

  643.   <tr>
    644. 

  644.     <td><b>Class</b></td>
    645. 

  645.     <td><b>Food</b></td>
    646. 

  646.     <td><b>Armor</b></td>
    647. 

  647.   </tr>
    648. 

  648.   <tr>
    649. 

  649.     <td><img src="img/ant_freeze.gif" /> <br> <code>SlowThrower</code></td>
    650. 

  650.     <td>4</td>
    651. 

  651.     <td>1</td>
    652. 

  652.   </tr>
    653. 

  653.   <tr>
    654. 

  654.     <td><img src="img/ant_stun.gif" /> <br> <code>StunThrower</code></td>
    655. 

  655.     <td>6</td>
    656. 

  656.     <td>1</td>
    657. 

  657.   </tr>
    658. 

  658. </table>
    659. 

  659. 

  660. <p>In order to complete the implementations of these two ants, you will need to
    661. 

  661. set their class attributes appropriately and implement the following three
    662. 

  662. functions:</p>
    663. 

  663. 

  664. <ul>
    665. 

  665.   <li>
    666. 

  666.     <code>make_slow</code> takes an <code>action</code> method and returns a new
    667. 

  667.     <code>action</code> method which performs the original action on turns where
    668. 

  668.     <code>colony.time</code> is even and does nothing on other turns.
    669. 

  669.   </li>
    670. 

  670. 

  671.   <li>
    672. 

  672.     <code>make_stun</code> takes an <code>action</code> method and returns a new
    673. 

  673.     <code>action</code> method which does nothing.
    674. 

  674.   </li>
    675. 

  675. 

  676.   <li>
    677. 

  677.     <code>apply_effect</code> takes an <code>effect</code> (either
    678. 

  678.     <code>make_slow</code> or <code>make_stun</code>), a <code>bee</code>, and a
    679. 

  679.     <code>duration</code>.  It then takes the bee's original action along with the
    680. 

  680.     "affected action" (the result of calling <code>effect</code> on the original
    681. 

  681.     action) and replaces the bee's action with a new action method that will call
    682. 

  682.     the affected action for <code>duration</code> turns and then will go back to
    683. 

  683.     calling the original action every turn.
    684. 

  684.   </li>
    685. 

  685. </ul>
    686. 

  686. 

  687. <p>Make sure to test your code!  Your code should be able to apply multiple
    688. 

  688. effects on a target (each new effect applies on top of whatever action method the
    689. 

  689. bee already has at that point, and the target returns to the previous action
    690. 

  690. when the new one runs out).</p>
    691. 

  691. 

  692. <p><strong>You are now done with the project!</strong>.  If you weren't able to
    693. 

  693. vanquish the bees' insane-mode assault plan before, do your new ants help?  Add
    694. 

  694. some water or design your own layout to keep things interesting.</p>
    695. 

  695. 

  696. 

  697. <p>Feel free to design additional ants, layouts, and assault plans and post them
    698. 

  698. to Piazza.</p>
    699. 

  699. 

  700. <p><b>Acknowledgements:</b> Tom Magrino and Eric Tzeng developed this project
    701. 

  701. with John DeNero.  Jessica Wan contributed the artwork.</p>
    702. 

  702. 

  703. </body>
    704. 

  704. </html>
    705.