c#

a9/Assignment 9.docx

CPSC 275

Fall 2017

Assignment 9: Piñata Game

Due: November 13 Late assignments not accepted

Overview

A few years ago, Google created a piñata game for its 15th anniversary. For this assignment, you will create a (somewhat less great) version of that game. You may work in groups of 2 for this assignment. You have an extended amount of time, but be sure to use it well—you will likely need the full time. (Google’s game is still available, if you’re feeling ambitious you can change yours to be more like Google’s—or awesome in other ways—as long as you meet the basic requirements: http://www.google.com/doodles/googles-15th-birthday)

The individual classes will be graded by hand, just to make sure they meet the requirements listed below. The rest of the program will be graded based on performance only, with both the professor and the other students grading the assignment. You must have the classes listed but you may adapt the fields and methods if you’d like—if you make changes, your grade will be based on how well organized and encapsulated they are. Most importantly, Form1 should know as little about the bat and piñata as possible.

Application Design

The game is played is played by swinging a bat at a moving piñata. The player’s goal is to hit the piñata as many times as possible without missing.

The piñata: the piñata should swing from the top of the program. Every time it is hit, the piñata should swing faster (and optionally higher as well). The piñata should respond to the hit—moving at the new speed in the direction the bat was moving. The piñata will not need to be realistic in a few ways: the piñata can keep swinging at the same speed indefinitely; also while a pendulum is faster at the bottom of its arc and slower at the top, your piñata can swing at the same speed from one end to the other.

The bat: the user swings the bat by pressing the space bar or enter key. The bat should swing forward (hopefully hitting the piñata), then swing back to the original spot. The user should not be able to swing again until the bat returns to the original spot. If the user hits the piñata, they gain an extra point (and the piñata behaves as described above). If the user misses the piñata, they lose the game. The bat should not be able to hit the piñata more than once per swing, and should only be able to hit the piñata on the initial swing, not the way back returning the bat to the start. The current points and high score should be shown at the bottom (high score can be just for that running of the program—doesn’t need to be remembered between programs.

Game play: when the user loses, the game should display a message (like a message box) and then reset, allowing the player to start again. The player should also be able to pause the game by pressing ‘p’ and then continue the game by pressing ‘p’ again.

Required Classes

You must define the following classes. Again, the fields and methods are just recommendations.

The Main Form:

· Has fields for a bat and a piñata

· Has a timer, which calls the pinata’s tick method and the bats tick method, then calls the Form’s refresh method so everything is redrawn

· loseGame, a method which displays a message to the user and resets the game

· The paint method should call the piñata and bat’s draw methods

Pinata Class:

· Fields:

· angle, the current angle of the piñata

· angle_change, the amount that the angle changes each step in the animation

· minAngle and maxAngle, the furthest the the piñata should go in each direction

· tick, a method which should advance the piñata in the animation. If the piñata reaches one end, this method should turn it around (reverse the angle_change)

· draw, a method which draws the piñata (should be passed a Graphics object)

· hit, a method that’s called if the bat contacts the piñata, and does the proper adjustments to the piñata (speeding it up, optionally making it swing higher)

· reset, resets the piñata to the original settings—it should be passed a Graphics object

Bat class:

· Fields:

· angle, and angle_change, similar to piñata

· phase, which uses an enumeration to track whether the bat is swinging forward, backwards, or is ready to swing

· tick, a method which should advance the piñata in the animation. If the piñata reaches the end of the swing, it should begin returning in the other direction. If the piñata returns to the start, it should stop.

· draw, a method that draws the piñata (should be passed a Graphics object)

· swing, which starts the player swinging if appropriate

· isCollision, which is passed a piñata object and returns true if the bat is contacting the piñata.

Grading

Your grade will be determined by three parts: my evaluation of the gameplay, other students’ evaluation of the gameplay, and my evaluation of whether the program follows the guidelines above (code is divided well between classes and there’s very little about the piñata and bat in Form1, for example).

Tips

· Start early on this project, it’s a lot of work, even with extra time and an extra person. “Budget” your time by making smaller goals—getting the piñata working, then getting the bat, then detecting collisions—then create time-frames for those goals. If your first project is to get the piñata moving, and it takes you a week, there won’t be time to finish the other parts of the project.

· Start with one piece of the project at a time—create the piñata class and get it drawn in its initial position first, then have it “tick” and move a little bit forward. Once you can repeat that, worry about having it go in both directions. But make sure you’re paying attention to the time for the project—make sure you’re making enough progress with these small goals. You can do the bat first, instead, if that seems more natural.

· Detecting collisions: an important part of the program is figuring out if the bat has hit the piñata. We’re going to simplify this a little:

· First, we’re going to only care if the bat is contacting the ball at a particular tick. In theory, if the bat and ball move a large amount on a tick, the could “jump” the ball during the tick—at first be to it’s right, and end up all the way over to its left in the next tick. We’ll want to make sure the piñata and bat don’t move huge amounts at each tick to avoid that (even if they move small amounts it can still happen right at the end of the bat, but it normally won’t be too obvious if it does).

· That means, after each tick’s code has moved the piñata and bat, we’ll want to call a method to figure out if the bat is hitting the piñata at that moment. It turns out finding out whether a line segment and circle intersect is mathematically challenging (a good solution using linear algebra is here: http://stackoverflow.com/questions/1073336/circle-line-segment-collision-detection-algorithm but that’s more complicated than we’ll probably want.

· We’re going to simplify a little to avoid the math above. Start by figuring out if the point at the end of the bat is in the circle. It’s actually easy to figure out if a point is in a circle—just find the distance between the point and the center of the circle ( ); if that distance is less than the radius, then the point is in the circle—otherwise it’s not.

· We want to add a little more because the bat may hit the piñata, but not the tip of that bat, so we’ll see if a few other points on that bat might hit the piñata. It’s easy to find some other points by combining the points at the base (the end of the bat that doesn’t move—let’s call that point 1) and the tip (the end that does move—let’s call that point 2). To get a point that is 90% of the way to the tip, use 90% of point 2 and 10% of point 1: x would be .9*x2 + .1 * x1 and you can calculate the y value using a similar formula. You can use that to find a few points on the bat that might hit the piñata, then calculating the distance with those points as well—if any of the points is contacting the piñata, then there’s a hit.