代写一个类似大鱼吃小鱼的游戏，小鱼不停的吃比他体积小的鱼，最终成长成大鱼后，和鲨鱼一战。
Overview of the Assignment
Fish Game: Create a fish game along the line of a classic game Shark! Shark!(
http://www.youtube.com/watch?v=HiHTZ8wZ_Hc&feature=related
).
In the classic game above, you start as a baby fish, growing by eating smaller
fishes, and staying alive by dodging larger fishes.
In this assignment, we will create a fish game that is similar to but not
exactly the same as this classic game – please always follow our requirements
as specified below when they are different. You may use as much of your code
from Assignment 2 as you need. Before you start, take some time to plan your
design.
This assignment is different from the last two and will require you think
through things in advance. Use Inheritance, polymorphism, key-based
interactions, ArrayList, and your knowledge of objects to write the code.
General Requirements& Learning Objectives
Learning objectives
- Create application using inheritance and polymorphism;
- Create key-based interactions;
- Use ArrayList to store and remove objects;
- Create dynamic text messages;
- Create simple Graphical User Interface (GUI) using GUI library
Programming Requirements
First of all, this assignment must be done using Java System Library (e.g.
using Graphics2D for drawing). You will get 0 if you use Processing library
(e.g. using PApplet for drawing) or any other 3rd party libraries.
This assignment has two iterative steps: Milestone: initial UML design and
code for drawing the fishes and Pond, and Final Deliverable: updated UML
design and code for fishing For the UML design document, you are graded on
completeness and correctness, and for the code on completeness and visual
style.
For the UML design document, you are graded on completeness and correctness,
and for the code on completeness and visual style.
MilestoneCode: Design Inheritance and Drawing Fishes and Sea
UML Design
Draw the initial UML that should include at least three classes to represent a
general fish and two types of enemy fish: shark and herbivore fish (i.e. weed
eating only). The enemy fishes must extend (i.e. be the subclasses of) the
general fish, and meet the following requirements:
First of all, you need to design your classes by following strict
Encapsulation for fields (except for constants), and provide public methods
only when it’s absolutely necessary. When working with inheritance, you are
allowed to relax access control of superclass’ fields from private to
protected so as to facilitate subclasses to access some of these fields
directly. As with public methods, you should relax access as such only when it
is absolutely necessary.
About the general fish
a) The general fish class should hold properties common to both player fish
and enemy fish, such as position (along x & y), velocity (along x and y),
angle for rotation, etc.
b) The general fish should also have some methods that could be either used
directly or overridden by its subclasses, such as drawFish(Graphics2D g2),
detectCollision(), detectOffScreen(), etc.
c) Please note the whole purpose to have the general fish class is to use it
as the superclass for player fish and enemy fish, you shouldn’t instantiate
any object of it.
About the enemy fishes
d) For the herbivore fish, you can basically use the fish that you have
created in Assignment 2 with modifications. For instance, you need to redesign
the code structure to accommodate inheritance, so that it will make use of the
fields and methods of the general fish while declaring its own fields such as
field for body color.
e) It must override at least drawFish(Graphics2D g2) method of the general
fish, to allow it to draw enemy fish using the color held in the field of body
color f) For the shark, you need to redesign a new fish that is visually in
the form of shark, which must has tail that is visually obvious. Beyond
inheriting the common properties of the general fish, the fish must have the
capability to eat other types of fish, including the herbivore fish and player
fish (included in the final deliverable)
g) A shark can eat other fishes only when it is facing them and close to their
mouth (i.e. in head-on position), so you need to have a method to check on
this.
h) Design FishPanel class and aggregate an ArrayList of general fish. Then add
as field a Timer object.
i) Create FishApp class as a subclass of JFrame, and associate it with the
FishPanel class.
j) The UML diagram must follow the UML notations for class and encapsulation.
Also the names of the class, fields and methods must follow the naming
convention with appropriate upper- or lower case for the initial and CamelCase
thereafter.
(Please note the structure of your code must match your UML design. Otherwise
you will lose credit for the UML design)
Coding per the design:
a) you should use the whole display window to represent the sea, leaving no
margins for any of the sides.
b) You must use an ArrayList of general fish to hold the enemy fishes, among
which two of them should be sharks and the rest herbivore fish.
c) The sharks initially should be in uniform color and size (it should be
equal to or slightly larger than the upper bound of herbivore fishes’ sizes),
while the herbivore fishes must be in randomized colors and sizes.
d) An herbivore fish is eaten by a shark when they go head-on (i.e. face to
face with mouths being close) and grow itself proportionally to the size of
the fish eaten. Otherwise they bounce off from each other.
e) Herbivore fishes must bounce off each other when they collide and NO eating
happen among themselves.
f) The enemy fishes must move left and right in the sea, with wavy (up and
down) movement based on the sin or cos function.
g) When an enemy fish fully goes off the screen or when it is killed, it must
be destroyed (i.e. removed from the ArrayList).
h) Enemy fishes should be respawned at a steady interval for up to a maximum
of 10 including no more than 8 herbivore fishes and no more than 2 sharks on
the screen (you should spawn one fish for each interval, and use a random
function call to give 80% of chance to herbivore fishes and 20% chance to
shark). Respawned fishes should move in randomly from either left or right
side of the window.
Final deliverable: Fish Game
Update the UML design to include
a) Class for player fish (avatar), which is a subclass of general fish as
well, and must include at least two unique visual features (e.g. dots, stripes
etc.) as represented by geom objects so that it will be easy to distinguish it
from those herbivore fishes.
b) The player fish must override at least the drawFish(Graphics2D g2) method
of general fish to draw it differently.
c) An inner class (you can download the membership notation from
Canvas|Resource and used it in the UML to indicate the nested relationship),
which extends KeyAdaptor class for key interaction per the features for
gameplay below.
d) GUI features as outlined below.
(Please note the structure of your code must match your UML design. Otherwise
you will lose credit for the UML design)
Coding per the design
About the player fish.
a) The movement of the player fish must be controlled by key inputs.
b) The player fish would grow by eating an herbivore fish smaller than itself,
and the growth must be proportional to the size of the fish eaten.
c) If it however tries to eat an herbivore fish that is greater than itself,
it will be killed, and before it runs out of its lives it respawns at a
location within the screen, which meets the digit-based requirements as
specified.
d) Eating can happen ONLY when the player fish and an enemy fish go in head-on
position as outline in the milestone part.
e) Whenever eating happens (no matter player fish eats enemy fish or vice
verse), certain bubbles or traces should be displayed as per the digit-based
requirements as specified.
f) Player fish can kill a shark by touching its tail 4 times before it moves
out of the screen. If however it touches on the shark any part other than the
tail, it will be killed instantly.
g) When a shark is touched by its tail it must flash with a different color to
demonstrate the effect, and when it is killed, it must change its shape in
certain way to show that it is dead while sinking to the bottom of the sea
(refer to Shark! Shark! for example but you can have your own appropriate
form)
About Style
As always, visual Design Matters! Grades will partially depend on how the game
looks, including sea design with appropriate, animated decoration objects,
animated fish features for enemy fishes and player fish, the HUD (e.g. using
fish images rather number to show number of lives, and nicely designed score
board). Beyond this, there are some specific requirements as follows based on
your student number.
