Interactive Python：Mini-project #8

yzwj2004

An Introduction to
Interactive Programming in Python

Mini-project description -RiceRocks (Asteroids)


For our last mini-project, we will complete the implementation ofRiceRocks, an updated version ofAsteroids, that we began last week.
You may start with either your code or theprogram templatewhich includes a full implementaiton
of Spaceship and will be released immediately after the deadline for the Spaceship mini-project (by making the preceding link live). If you start with your own code, you should add the splash screen image that you dismiss with a mouse click before starting
this mini-project. We strongly recommend using Chrome for this mini-project since Chrome's superior performance will become apparent when you program attempts to draw dozens of sprites.
Mini-project development process

At the end of this project, your game will have multiple rocks and multiple missiles. You will lose a life if your ship collides with a rock and you will score points if your missile collides with a rock. You will keep track of the score and
lives remaining and end the game at the proper time. You may optionally add animated explosions when there is a collision.
Phase one - Multiple rocks
For this phase, you will keep a set of rocks and spawn new rocks into this set. This requires the following steps:

• Removea_rockand
  replace it withrock_group. Initialize
  the rock group to an empty set. Modify your rock spawner to create a new rock (an instance of a Sprite object) and add it torock_group.
  
• Modify your rock spawner to limit the total number of rocks in the game at any one time. We suggest you limit it to 12. With too many rocks the game becomes less fun and the animation slows down significantly.
  
• Create a helper functionprocess_sprite_group.
  This function should take a set and a canvas and call the update and draw methods for each sprite in the group.
  
• Call theprocess_sprite_groupfunction
  onrock_groupin the draw
  handler.
  

Phase two - Collisions
For this phase, you will detect collisions between the ship and a rock. Upon a collision, the rock should be destroyed and the player should lose a life. To implement ship-rock collisions, you need to do the following:

• Add acollidemethod
  to the Sprite class. This should take another_objectas
  an argument and returnTrueif
  there is a collision orFalseotherwise.
  For now, this other object will always be your ship, but we want to be able to use this collide method to detect collisions with missiles later, as well. Collisions can be detected using the radius of the two objects. This requires you to implement methodsget_positionandget_radiuson
  both the Sprite and Ship classes.
  
• Implement agroup_collidehelper
  function. This function should take a setgroupand
  an a spriteother_objectand
  check for collisions betweenother_objectand
  elements of the group. If there is a collision, the colliding object should be removed from the group. To avoid removing an object from a set that you are iterating over (which can cause you a serious debugging headache), iterate over a copy of the set created
  viaset(group). This function should return
  the number of collisions. Be sure to use thecollidemethod
  from part 1 on the sprites in the group to accomplish this task.
  
• In the draw handler, use thegroup_collidehelper
  to determine if the ship hit any of the rocks. If so, decrease the number of lives by one. Note that you could have negative lives at this point. Don't worry about that yet.
  

At this point, you should have a game of "dodge 'em". You can fly around trying to avoid the rocks!
Phase three - Missiles
For this phase, you will keep a set of missiles and spawn new missiles into this set when firing using the space bar. This requires the following steps:

• Removea_missileand
  replace it withmissile_group. Initialize
  the missile group to an empty set. Modify your shoot method ofmy_shipto
  create a new missile (an instance of the Sprite class) and add it to themissile_group.
  If you use our code, the firing sound should play automatically each time a missile is spawned.
  
• In the draw handler, use your helper functionprocess_sprite_groupto
  processmissile_group. While you can now
  shoot multiple missiles, you will notice that they stick around forever. To fix this, we need to modify the Sprite class and theprocess_sprite_groupfunction.
  
• In theupdatemethod
  of the Sprite class, increment the age of the sprite every timeupdateis
  called. If the age is greater than or equal to the lifespan of the sprite, then we want to remove it. So, returnFalse(meaning
  we want to keep it) if the age is less than the lifespan andTrue(meaning
  we want to remove it) otherwise.
  
• Modifyprocess_sprite_groupto
  check the return value ofupdatefor
  sprites. If it returnsTrue, remove the
  sprite from the group. Again, you will want to iterate over a copy of the sprite group inprocess_sprite_groupto
  avoid deleting from the same set over which you are iterating.
  

Phase four - Collisions revisitedNow, we want to destroy rocks when they are hit by a missile. We can't quite usegroup_collide, because we want
to check for collisions between two groups. All we need to do is add one more helper function:

• Implement a final helper functiongroup_group_collidethat
  takes two groups of objects as input.group_group_collideshould
  iterate through the elements of a copy of the first group using afor-loop
  and then callgroup_collidewith
  each of these elements on the second group.group_group_collideshould
  return the number of elements in the first group that collide with the second group as well as delete these elements in the first group.
  
• Callgroup_group_collidein
  the draw handler to detect missile/rock collisions. Increment the score by the number of missile collisions.
  

Phase five - Finish it off
You now have a mostly working version ofRiceRocks!!! Let's add a few final touches.

• Add code to the draw handler such that, if the number of lives becomes 0, the game is reset and the splash screen appears. In particular, set the flagstartedtoFalse,
  destroy all rocks and prevent any more rocks for spawning until the game is restarted.
  
• When the game restarts, make sure the lives and the score are properly reset. Starting spawning rocks again. Restart the soundtrack.
  
• When you spawn rocks, you want to make sure they are some distance away from the ship. Otherwise, you can die when a rock spawns on top of you, which isn't much fun. One simple way to acheive this effect to ignore a rock spawn event
  if the spawned rock is too close to the ship.
  
• Experiment with varying the velocity of rocks based on the score to make game play more difficult as the game progresses.
  
• Tweak any constants that you have to make the game play the way you want.
  

Congratulations! You have completed the assignment. Enjoy playing your game!!!
Bonus
The following will not be graded. Feel free to try this, but do not break any of the other game functionality. We strongly recommend that you save your work before doing this and keep track of it, so you can submit a working version of the first
five phases if you end up breaking your game trying to add more features.
One thing that is missing in your game is explosions when things collide. We have provided a tiled explosion image that you can use to create animated explosions. To get things working, you will need to do a few things:

• In the draw method of the Sprite class, check ifself.animatedisTrue.
  If so, then choose the correct tile in the image based on the age. The image is tiled horizontally. Ifself.animatedisFalse,
  it should continue to draw the sprite as before.
  
• Create anexplosion_groupglobal
  variable and initialize it to an empty set.
  
• Ingroup_collide,
  if there is a collision, create a new explosion (an instance of the Sprite class)and add it to theexplosion_group.
  Make sure that each explosion plays the explosion sound.
  
• In the draw handler, useprocess_sprite_groupto
  processexplosion_group.
  

　　You should now have explosions working!
　　代码链接：点击打开链接
　　代码如下：

　　

# program template for Spaceship
import simplegui
import math
import random
# globals for user interface
WIDTH = 800
HEIGHT = 600
score = 0
lives = 3
time = 0.5
started=True
velrate=1
class ImageInfo:
def __init__(self, center, size, radius = 0, lifespan = None, animated = False):
self.center = center
self.size = size
self.radius = radius
if lifespan:
self.lifespan = lifespan
else:
self.lifespan = float('inf')
self.animated = animated
def get_center(self):
return self.center
def get_size(self):
return self.size
def get_radius(self):
return self.radius
def get_lifespan(self):
return self.lifespan
def get_animated(self):
return self.animated

# art assets created by Kim Lathrop, may be freely re-used in non-commercial projects, please credit Kim
# debris images - debris1_brown.png, debris2_brown.png, debris3_brown.png, debris4_brown.png
#                 debris1_blue.png, debris2_blue.png, debris3_blue.png, debris4_blue.png, debris_blend.png
debris_info = ImageInfo([320, 240], [640, 480])
debris_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/debris2_blue.png")
# nebula images - nebula_brown.png, nebula_blue.png
nebula_info = ImageInfo([400, 300], [800, 600])
nebula_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/nebula_blue.png")
# splash image
splash_info = ImageInfo([200, 150], [400, 300])
splash_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/splash.png")
# ship image
ship_info = ImageInfo([45, 45], [90, 90], 35)
ship_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/double_ship.png")
# missile image - shot1.png, shot2.png, shot3.png
missile_info = ImageInfo([5,5], [10, 10], 3, 50)
missile_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/shot2.png")
# asteroid images - asteroid_blue.png, asteroid_brown.png, asteroid_blend.png
asteroid_info = ImageInfo([45, 45], [90, 90], 40)
asteroid_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/asteroid_blue.png")
# animated explosion - explosion_orange.png, explosion_blue.png, explosion_blue2.png, explosion_alpha.png
explosion_info = ImageInfo([64, 64], [128, 128], 17, 24, True)
explosion_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/explosion_alpha.png")
# sound assets purchased from sounddogs.com, please do not redistribute
soundtrack = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/soundtrack.mp3")
missile_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/missile.ogg")
missile_sound.set_volume(.5)
ship_thrust_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/thrust.ogg")
explosion_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/explosion.mp3")
# helper functions to handle transformations
def angle_to_vector(ang):
return [math.cos(ang), math.sin(ang)]
def dist(p,q):
return math.sqrt((p[0] - q[0]) ** 2+(p[1] - q[1]) ** 2)
def process_sprite_group(canvas,rock_group):
for tmp in rock_group:
tmp.draw(canvas)
if tmp.update():
rock_group.remove(tmp)
def group_collide(group,other_object):
numcol=0
for tmp in set(group):
if tmp.collide(other_object):
group.remove(tmp)
numcol+=1
return numcol
def group_group_collide(group1,group2):
numcol=0
for tmp in set(group1):
tmpcol=group_collide(group2,tmp)
if tmpcol:
numcol+=tmpcol
group1.remove(tmp)
return numcol
# Ship class
class Ship:
def __init__(self, pos, vel, angle, image, info):
self.pos = [pos[0],pos[1]]
self.vel = [vel[0],vel[1]]
self.thrust = False
self.angle = angle
self.angle_vel = 0
self.image = image
self.image_center = info.get_center()
self.image_size = info.get_size()
self.radius = info.get_radius()
def draw(self,canvas):
if self.thrust:
self.image_center[0]=135
else:
self.image_center[0]=45
canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size,self.angle)
def update(self):
self.vel[0]*=0.98
self.vel[1]*=0.98
self.pos[0]+=self.vel[0]
self.pos[0]%=WIDTH
self.pos[1]+=self.vel[1]
self.pos[1]%=HEIGHT
self.angle+=self.angle_vel
if self.thrust:
ship_thrust_sound.play()
else:
ship_thrust_sound.rewind()
if self.thrust:
foward=angle_to_vector(self.angle)
self.vel[0]+=foward[0]/10
self.vel[1]+=foward[1]/10
def shoot(self):
global a_missile
foward=angle_to_vector(self.angle)
tmppos=[self.pos[0]+45*foward[0],self.pos[1]+45*foward[1]]
tmpvel=[self.vel[0]+foward[0]*5,self.vel[1]+foward[1]*5]
a_missile = Sprite(tmppos, tmpvel, 0, 0, missile_image, missile_info, missile_sound)
missile_group.append(a_missile)
missile_sound.play()
def get_position(self):
return self.pos
def get_radius(self):
return self.radius
# Sprite class
class Sprite:
def __init__(self, pos, vel, ang, ang_vel, image, info, sound = None):
self.pos = [pos[0],pos[1]]
self.vel = [vel[0],vel[1]]
self.angle = ang
self.angle_vel = ang_vel
self.image = image
self.image_center = info.get_center()
self.image_size = info.get_size()
self.radius = info.get_radius()
self.lifespan = info.get_lifespan()
self.animated = info.get_animated()
self.age = 0
if sound:
sound.rewind()
sound.play()
def draw(self, canvas):
if self.animated:
tmpcenter=[self.image_center[0]+self.age*self.image_size[0],self.image_center[1]]
canvas.draw_image(self.image, tmpcenter, self.image_size, self.pos, self.image_size,self.angle)
else:
canvas.draw_image(self.image, self.image_center, self.image_size, self.pos, self.image_size,self.angle)
def update(self):
self.pos[0]+=self.vel[0]
self.pos[0]%=WIDTH
self.pos[1]+=self.vel[1]
self.pos[1]%=HEIGHT
self.angle+=self.angle_vel
self.age+=1
if self.age>self.lifespan:
return True
else:
return False
def get_position(self):
return self.pos
def get_radius(self):
return self.radius
def collide(self,other_object):
if dist(self.get_position(),other_object.get_position())<self.get_radius()+other_object.get_radius():
foward=angle_to_vector(self.angle)
tmppos=[self.pos[0]+self.get_radius(),self.pos[1]+self.get_radius()]
a_explosion=Sprite(tmppos, [0,0], 0, 0, explosion_image, explosion_info, explosion_sound)
explosion_group.append(a_explosion)
return True
else:
return False

def draw(canvas):
global time,lives,score,rock_group,missile_group,started,explosion_group
# animiate background
time += 1
center = debris_info.get_center()
size = debris_info.get_size()
wtime = (time / 8) % center[0]
canvas.draw_image(nebula_image, nebula_info.get_center(), nebula_info.get_size(), [WIDTH / 2, HEIGHT / 2], [WIDTH, HEIGHT])
canvas.draw_image(debris_image, [center[0] - wtime, center[1]], [size[0] - 2 * wtime, size[1]],
[WIDTH / 2 + 1.25 * wtime, HEIGHT / 2], [WIDTH - 2.5 * wtime, HEIGHT])
canvas.draw_image(debris_image, [size[0] - wtime, center[1]], [2 * wtime, size[1]],
[1.25 * wtime, HEIGHT / 2], [2.5 * wtime, HEIGHT])
# draw ship and sprites
my_ship.draw(canvas)
process_sprite_group(canvas,rock_group)
process_sprite_group(canvas,missile_group)
process_sprite_group(canvas,explosion_group)
canvas.draw_text('lives:'+str(lives), (50, 50), 24, "White")
canvas.draw_text('score:'+str(score), (WIDTH-100, 50), 24, "White")
if group_collide(rock_group,my_ship):
lives-=1
if lives==0:
started=False
rock_group=[]
explosion_group=[]
canvas.draw_image(splash_image,splash_info.get_center(), splash_info.get_size(), [WIDTH / 2, HEIGHT / 2], splash_info.get_size())
if group_group_collide(rock_group,missile_group):
score+=1
# update ship and sprites
my_ship.update()
# timer handler that spawns a rock   
def rock_spawner():
global rock_group,started,velrate
if not started:return
if len(rock_group)<12:
pos=[random.random()*WIDTH, random.random()*HEIGHT]
while dist(my_ship.get_position(),pos)<200:
pos=[random.random()*WIDTH, random.random()*HEIGHT]
a_rock = Sprite(pos, [random.random()*velrate, random.random()*velrate], random.random()*2*math.pi, random.random()*0.1, asteroid_image, asteroid_info)
velrate+=0.2
rock_group.append(a_rock)
def keydown(key):
if key==simplegui.KEY_MAP['left']:
my_ship.angle_vel=-0.08
elif key==simplegui.KEY_MAP['right']:
my_ship.angle_vel=0.08
elif key==simplegui.KEY_MAP['up']:
my_ship.thrust=True
elif key==simplegui.KEY_MAP['space']:
my_ship.shoot()
def keyup(key):
if key==simplegui.KEY_MAP['left']:
my_ship.angle_vel=0
elif key==simplegui.KEY_MAP['right']:
my_ship.angle_vel=0
elif key==simplegui.KEY_MAP['up']:
my_ship.thrust=False
def mouse_handler(pos):
global started,lives,score,velrate,my_ship
if started==False and dist(pos,[WIDTH / 2, HEIGHT / 2])<200:
started=True
lives=3
score=0
velrate=1
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
# initialize frame
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)
# initialize ship and two sprites
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
rock_group=[]
missile_group=[]
explosion_group=[]
# register handlers
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)  
frame.set_keyup_handler(keyup)  
frame.set_mouseclick_handler(mouse_handler)
timer = simplegui.create_timer(1000.0, rock_spawner)
# get things rolling
timer.start()
frame.start()