ITEC 380 2012fall ibarland tlewis32

home—lectures—exams—hws—breeze (snow day)

hw05
continuing asteroids

Due Oct.12 (Fri) in class. (Do not wait until Wed. night to start this!)

Implement the functions below. Following those requirements is a discussion of ways our game can differ from the original game.

All non-drawing functions require at least two test cases! (Point-values are subject to slight tweaking.)
1. (2pts) Re-write move-astrs to involve a call to map. (It will be easy to check that this works, since you already have several test cases.)
2. (4pts) Design a “world” structure, to represent an entire asteroids game (just the ship and asteroids, for now). Construct some examples.
3. (6pts) Write move-world : world -> world and draw-world : world -> image.
4. (3pts) Have your code call big-bang¹, providing it on-tick and on-draw handlers.
   You can look over the file big-bang-example-balloon.rkt dicussed in class, for an example of using big-bang (slightly longer/commented than racket-lang.org's splash page “Start Quickly” examples include a balloon-inflating example).
5. (9pts) Implement controls: Provide a function² ship, key → ship. If the provided key are the right or left arrows, then the ship rotates; if the provided key is (say) the up-arrow then accelerate the ship in the direction it's facing.
   I had several helper functions for this (ranging from accelerate-ship to degreesToRadians). For all functions, write test cases (before the function body), as usual.
6. We will approximate collision-detection by treating all our objects (ships, asteroids, and later bullets) as circles³. Half the points are for test cases.
   1. (4pts) Write overlap?, which takes info about two circles (two (x,y) centers and two radii), and returns whether they overlap.
   2. (3pts) Write collide-ship-astr?, which takes in a ship and an asteroid, and returns whether or not they are colliding. (You can approximate collision by whether their "bounding circles" overlap.)
   3. (3pts) Write collide-ship-astrs?, which takes in a ship and a list of asteroids, and returns whether or not the ship collides with any of them.
   4. (2pts) Provide a stop-when handler to big-bang, using lambda.

Features, Requirements, and Extras

We're looking for a asteroids-like game, but we don't need to implement every feature of the original. In particular, it's acceptable to punt on the following issues.

• Objects can be drawn quite differently from the original. (Keep it simple at first; you can always make it look fancier later.)
• No need to draw the "acceleration" flame for the ship, or even to keep track of whether the accelerate key is being held — for simplicity, I suggest having the accelerate key merely impart one “kick” of acceleration.⁴
• You don't have to have a friction term, to slow the ship. (There's not actually any friction in space! … though it does make the game more playable.) (The Atari 2600 version didn't include friction.)
• Asteroids can behave differently than the game proper, as long as it's reasonable.
• No sounds required (though you are certainly welcome to call play-sound if you like). Please, no copyrighted sounds. If you know of a website that has some free-to-use sounds (e.g. under a creative commons license), please post on the discussion boards. Or, record your own!
• We don't need to keep track of a score.
• We'll defer bullets for a while.
• No marauding UFOs.

• be proficient at list-processing functions (including maps, filters, and folds, which we'll talk about later);
• Have a solid understanding of how one can write a program functionally, without ever assigning to a variable;
• better understand model-view-controller;
• Rid the ether of dangerous, life-threatening asteroids.

Opportunities are rife for extra-credit, by adding additional features. Don't do this until you get the above functionality working, though!

• Include a signature for every function you write, as well as a short description of what it does (which can be just a couple of words, and/or taken from the hw). Note that using self-documenting names goes a long way towards not needing other comments.
  (This shouldn't really need saying; it's been required of every function you've written since ITEC120!)
• You may use code from the posted solutions, but (as with all code⁵ you don't write) you should cite your source.
• Please put a clear dividing point between code for requirements from previous homeworks, and any changed/updated code that is required for this assignment.
• You may want to remind yourself of how the original game plays (keeping in mind that we don't need to implement most inessential features).

7. (2pts) What is the signature for map?                                                             
   (that is, the version of map we wrote in class, and that is in the student languages). Give your answer in a comment.

   Note: “function” is not a specific-enough type, although something like “number → boolean” is. Similarly, “list” is not specific enough⁶, but “(listof string)” is.

8. (4pts) Write a function which takes in a list of strings (some of which might be numerals), and returns a list of just the numerals, in descending numeric order (with any leading zeroes removed⁷). For example, given (list "hello" "35" "009" "hmm" "-7" "43"), your function would return (list "43" "35" "9" "-7").

   Your function should consist of calls to map and filter (and sort), as well as routine functions like string->number. It should not need cond/if, nor need any auxilliary helper functions. It is possible to write the function-body in a single line (or an equivalent let* which uses four local identifiers).

9. (4pts)
   1. Using just a call to filter and lambda, write an expression which returns all numbers in (list 7 13 9 10 11 19 20 21 99 15 0) that are in the half-open interval [10,20) (that is, numbers x in the range 10 ≤ x < 20).
   2. Write a function which takes in a list of real numbers and two real numbers a,b, and returns all elements in the list which are in the half-open interval [a,b) Your function-body should just be a call to filter, with an appropriate lambda.

10. (4pts) Write filter-out, which does the opposite of filter: it takes in a predicate and a list, and returns a list of all elements which fail the filter. For example, (filter-out even? (list 2 3 4 5)) should return (list 3 5). Give at least two additional test cases.

    Write your function without using filter or other higher-order functions — instead just use the standard list-processing template.

home—lectures—exams—hws—breeze (snow day)

©2012, Ian Barland, Radford University Last modified 2012.Oct.19 (Fri)

Please mail any suggestions (incl. typos, broken links) to ibarlandradford.edu