def check_collisions(self):
collided_aliens = sprite.groupcollide(self.aliens, self.player_bullets,
False, False)
collided_bonus = sprite.groupcollide(self.bonus, self.player_bullets,
False, False)
hit_players = sprite.groupcollide(self.players, self.alien_bullets,
False, False)
collided_players_with_aliens = sprite.groupcollide(
self.players, self.aliens, False, False)
for alien in collided_aliens:
for bullet in collided_aliens[alien]:
bullet.hit(alien)
for bonus in collided_bonus:
for bullet in collided_bonus[bonus]:
bullet.hit(bonus)
for player in hit_players:
for bullet in hit_players[player]:
bullet.hit(player)
for player in collided_players_with_aliens:
for alien in collided_players_with_aliens[player]:
alien.hit(player)
def collision(self):
bullets = Group()
bullets.add(self.player.bullets)
bullets.add(self.room.enemies_bullets)
groupcollide(bullets, self.room.walls, True, False)
spritecollideany(self.player,
self.room.enemies_bullets,
collided=self.__collide_with('bullet'))
groupcollide(self.room.enemies,
self.player.bullets,
False,
False,
collided=self.__collide_with('bullet'))
spritecollideany(self.player,
self.room.hearts,
collided=self.__collide_with('heart'))
spritecollideany(self.player,
self.room.coins,
collided=self.__collide_with('coin'))
spritecollideany(self.player,
self.room.energy_orbs,
collided=self.__collide_with('energy_orb'))
if self.room.portal is not None:
entered = self.player.rect.colliderect(self.room.portal.rect)
if entered:
self.new_room()
self.player.rooms_survived += 1
def run_game():
pygame.init() # intitialize all the pygame modules
game_settings = Settings()
screen = pygame.display.set_mode(
game_settings.screen_size) # Set the screen size with set_mode
pygame.display.set_caption(
"Monster Attack") # set teh message on the status bar
hero = Hero(
screen) # set a variable equal to the class and pass it the screen
bullets = Group() #set the bullets to group
bad_guy = Group()
bad_guy.add(Bad_guy(screen))
tick = 0
while 1: # run this loop forever...
gf.check_events(
hero, bullets, game_settings, screen
) # call gf (aliased for game_functions module) and get the check_events method
hero.update() #update the hero location
bad_guy.update(hero, game_settings.enemy_speed)
groupcollide(bullets, bad_guy, True, True)
tick += 1
if tick % 150 == 0:
bad_guy.add(Bad_guy(screen))
bullets.update() # call the update method in the while loop
gf.update_screen(game_settings, screen, hero, bullets,
bad_guy) # call the update_screen
for bullet in bullets: #get rid of bullets that are off the screen
if bullet.rect.left <= 1000: #bullet bottom is at the top of the screen
bullets.remove(bullet) #call remove() against the group
def simulate(self, time_delta):
super().simulate(time_delta)
player = self.groups["player"]
bullets = self.groups["bullets"]
enemies = self.groups["enemy"]
groupcollide(player, enemies, True, True)
groupcollide(enemies, bullets, True, True)
def update(self):
if self.is_gameover():
self.player.kill()
self.spawnticker += 1
if self.spawnticker >= self.spawntime:
#print "ICE SPAWNED"
self.meteors.add(IceMeteor((randrange(0,800),randrange(0,600)),self.bounds, 90, "ice"))
if self.spawnticker >= self.spawntime:
#print "spawned!"
self.meteors.add(RockMeteor((randrange(0,800),randrange(0,600)),self.bounds, 90, "rock"))
self.spawnticker = 0
#update
self.meteors.update()
ImpactGroup.impacts.update()
self.player.update()
ShieldGroup.shields.update()
FallingGroup.fallings.update()
#collisions
coll = groupcollide(self.player_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
coll = groupcollide(self.robot_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
def simulate(self, time_delta):
super().simulate(time_delta)
player = self.groups[sprites.Player.group]
bullets = self.groups[sprites.Bullet.group]
enemies = self.groups[sprites.Enemy.group]
groupcollide(player, enemies, True, True)
groupcollide(enemies, bullets, True, True)
def run_game():
tick = 0
while 1923014810498219048120948:
if game_settings.game_active:
game_func.check_events(screen, game_settings, squares, characters,
bullets)
# screen.fill(game_settings.bg_color);
tick += 1
if tick % 30 == 0 or tick == 1:
dinosaurs.add(Dinosaur(screen, game_settings))
dinosaur_got_shot = groupcollide(dinosaurs, bullets, False, False)
character_got_hit = groupcollide(dinosaurs, characters, False,
True)
for dinosaur in dinosaur_got_shot:
# print dinosaur;
if dinosaur.yard_row == dinosaur_got_shot[dinosaur][
0].yard_row:
bullets.remove(dinosaur_got_shot[dinosaur][0])
dinosaur.hit(1)
if (dinosaur.health <= 0):
dinosaurs.remove(dinosaur)
# os.system("say ow")
game_settings.dinosaur_in_row[dinosaur.yard_row] -= 1
game_func.update_screen(screen, game_settings, background, dinosaurs,
squares, characters, bullets, tick)
pygame.display.flip()
def run_game():
tick = 0;
while 1:
gf.check_events(screen,game_settings, squares, plants,bullets,icons);
if game_settings.game_active:
tick += 1;
if tick % 30 == 0:
zombies.add(Zombie(screen,game_settings));
zombies_hit = groupcollide(zombies, bullets, False, False);
# print zombies_hit;
for zombie in zombies_hit:
# print zombie;
# print zombies_hit[zombie];
if zombie.yard_row == zombies_hit[zombie][0].yard_row:
# print "Same row!!!";
bullets.remove(zombies_hit[zombie][0]);
zombie.hit(1);
if(zombie.health <= 0):
zombies.remove(zombie);
game_settings.zombie_in_row[zombie.yard_row] -= 1;
game_settings.zombies_killed += 1;
# Create a dictionary with a key of Zombie and a value of a list of Plants that zombie has colided with
zombies_eating = groupcollide(zombies, plants, False, False);
# Loop through the dictionary
for zombie in zombies_eating:
# Set a var for the Plant (to save our eyes)
damaged_plant = zombies_eating[zombie][0];
# Check to see if the zombie and plant are in the same row
if zombie.yard_row == damaged_plant.yard_row:
# Zombie has run into a plant in it's row
# start/continue eating... stop moving if neccessary
zombie.moving = False;
# Check to see if zombie takes a bite
if time.time() - zombie.started_eating > zombie.damage_time:
# print "Zombie just took a bite";
# Run chomp
zombie.zombie_chomp(damaged_plant);
# plant.take_damage();
# update zombies last bite time
zombie.started_eating = time.time()
# remove the plant if it's 0 or below
if damaged_plant.health <= 0:
plants.remove(damaged_plant);
# start the zombie march again
zombie.moving = True;
# zombies_eating = {
# "key": 2,
# <Zombie>: [
# <Plant>,
# <Plant>,
# <Plant>,
# <Plant>
# ]
# }
gf.update_screen(screen,game_settings,background,zombies,squares,plants,bullets,tick,icons);
pygame.display.flip();
def simulate(self, time_delta):
super().simulate(time_delta)
self.spawner.spawn(time_delta)
player = self.groups[Player.group]
lasers = self.groups[Laser.group]
enemies = self.groups[Enemy.group]
groupcollide(player, enemies, True, True)
groupcollide(enemies, lasers, True, True)
def run_game():
global frame
# ** -- INIT ALL PYGAME STUFF -- **
pygame.init()
# ** -- set up a tuple for the screen size, horiz, vert -- **
screen_size = (1000, 800)
# ** -- setting background color with RGB -- **
background_color = (Red, Green, Blue)
# if (frame % 600 == 0):
# background_color = (randint(0,255), randint(0,255), randint(0,255))
# ** -- create screen size -- **
screen = pygame.display.set_mode(screen_size)
# ** -- set a caption on terminal window -- **
pygame.display.set_caption("A Heroic 3rd Person Shooter")
the_player = Player(screen, './images/Hero.png', 100, 100)
bad_dude = Enemy(screen)
the_player_group = Group()
the_player_group.add(the_player)
enemies = Group()
enemies.add(bad_dude)
bullets = Group()
# ** -- Main game loop. Run forever or until break -- **
while 1:
frame += 1
if (frame % 100 == 0):
enemies.add(Enemy(screen))
# ** -- Fill screen with background color -- **
screen.fill(background_color)
if (frame % 3600 == 0):
background_color = (randint(0,255), randint(0,255), randint(0,255))
# snail_rave(screen,frame,background_color)
# ** -- the escape hatch (from while) -- **
check_events(screen,the_player,bullets)
# clear the screen for the next time through the loop
for player in the_player_group:
the_player.draw_me()
for bad_dude in enemies:
bad_dude.draw_me()
bad_dude.update_me(the_player)
# update and draw the bullets
for bullet in bullets:
bullet.draw_bullet()
bullet.update()
hero_died = groupcollide(the_player_group,enemies,True,False)
bullet_death = groupcollide(bullets,enemies,True,True)
pygame.display.flip()
def run_game():
# Init all the pygame stuff
pygame.init()
# Set up a tuple for the screensize, (horiz,vert)
screen_size = (1000,800)
# Set up a tuple for the bg color
background_color = (82,111,53)
# Create a pygame screen to use
screen = pygame.display.set_mode(screen_size)
# Set a caption on the terminal window
pygame.display.set_caption("A heroic 3rd person shooter")
the_player = Player(screen,'./images/Hero.png',100,100)
the_player_group = Group()
the_player_group.add(the_player)
bad_guy = Enemy(screen)
enemies = Group()
enemies.add(bad_guy)
bullets = Group()
tick = 0
# Main game loop. Run forever... (or until break)
while 1:
tick += 1
if tick % 50 == 0:
enemies.add(Enemy(screen))
screen.fill(background_color)
check_events(the_player, screen, bullets)
# Draw the player
for player in the_player_group:
player.draw_me()
# Update and Draw the bad guy
for bad_guy in enemies:
bad_guy.update_me(the_player)
bad_guy.draw_me()
# Update and draw the bullets
for bullet in bullets:
bullet.update()
bullet.draw_bullet()
# Check for collisions...
hero_died = groupcollide(the_player_group, enemies, True, False)
# print hero_died
bullet_hit = groupcollide(bullets,enemies,True,True)
print bullet_hit
# Clear the screen for the next time through the loop
pygame.display.flip()
def run_game():
#Init all pygame stuff
pygame.init() #pygame is an object and init() is a method
#Set up a tuple for the screen_size(horiz, vert)
screen_size = (1000, 800)
#Set up a tuple for the background color
background_color = (82, 111, 53) #RGB
#Create a pygame screen to use
screen = pygame.display.set_mode(
screen_size) #set_mode is looking for a tuple from the pygame docs
#Set a caption on the terminal window
pygame.display.set_caption("A Heroic 3rd Person Shooter")
the_player = Player(screen, "./images/Hero.png", 100, 100)
bad_guy = Enemy(screen)
the_player_group = Group()
the_player_group.add(
the_player) #"add" is like append since this is owned by pygame
enemies = Group()
enemies.add(bad_guy)
bullets = Group()
tick = 0
#Main game loop. Run forever... (or until break)
while 1: #use "while 1" if the code is fairly simple (game_on = True for more complex)
tick += 1
if tick % 50 == 0:
enemies.add(Enemy(screen))
screen.fill(background_color)
check_events(the_player, screen, bullets)
#Draw the player
for player in the_player_group: #player will only be drawn based on hero_died below
player.draw_me()
#Update and draw the bullets
for bullet in bullets:
bullet.update()
bullet.draw_bullet()
#Update and draw the bad guy
for bad_guy in enemies:
bad_guy.update_me(the_player)
bad_guy.draw_me()
#Check for collisions...
hero_died = groupcollide(the_player_group, enemies, True,
False) #will make hero die when they collide
# print hero_died
groupcollide(bullets, enemies, True, True)
#Clear the screen for the next time through the loop
pygame.display.flip()
def simulate(self, time_delta):
self.run_time += time_delta
while self.next_spawn <= self.run_time:
sprites.Enemy(self, self.next_x)
self.next_spawn, self.next_x = next(self.spawn)
super().simulate(time_delta)
player = self.groups[sprites.Player.group]
bullets = self.groups[sprites.Bullet.group]
enemies = self.groups[sprites.Enemy.group]
groupcollide(player, enemies, True, True)
groupcollide(enemies, bullets, True, True)
def run_game():
# INITIALIZE ALL THE PYGAME STUFF
pygame.init()
# Set up a tuple for the screen size: (horizontal, vertical)
screen_size = (1000, 800)
# Set up a tuple for the bg color
# background_color = (140,200,150)
background_color = (255, 245, 255)
# Create a pygame screen to use
screen = pygame.display.set_mode(screen_size)
# Set a caption on the terminal window
pygame.display.set_caption("MIND BULLETS")
the_player = Player(screen, "./images 2/Hero.png", 100, 100)
# a_bullet = Bullet(screen,the_player,)
the_player_group = Group()
the_player_group.add(the_player)
the_enemy = Enemy(screen)
enemies = Group()
enemies.add(the_enemy)
bullets = Group()
tick = 0
# Main game loop run forever or until break
while 1:
tick += 1
if tick % 50 == 0:
enemies.add(Enemy(screen))
screen.fill(background_color)
# The escape hatch from while
check_events(the_player, screen, bullets)
# Draw the player
for player in the_player_group:
player.draw_me()
for enemy in enemies:
enemy.draw_me()
enemy.update_me(the_player)
for bullet in bullets:
bullet.update()
bullet.draw_bullet()
player_died = groupcollide(the_player_group, enemies, True, False)
bullet_hit = groupcollide(bullets, enemies, True, True)
# Clear the screen for the next time through the loop
pygame.display.flip()
def update(self):
self.player.move()
self.shots.update()
self.alien_shots.update()
self.aliens.update()
for a in self.aliens:
shot = a.get_shot()
if shot:
self.alien_shots.add(shot)
self.draw()
groupcollide(self.shots, self.aliens, True, True, collided=collide_mask)
if spritecollideany(self.player, self.alien_shots, collided=collide_mask):
self.game.exit()
if not self.aliens:
self.game.exit()
def collide(self, keysGroup, valuesGroup, playerPos):
"""Uses pygame collision to collide two sprite groups."""
collDict = sprite.groupcollide(
keysGroup, valuesGroup, False, False)
for collided in collDict.keys():
for collider in collDict[collided]:
collided.setCollided(collider)
def run_game(): tick = 0; while 1: if game_settings.game_active: gf.check_events(screen, game_settings, squares, plants, bullets); # screen.fill(game_settings.bg_color); tick += 1; if tick % 30 == 0: zombies.add(Zombie(screen, game_settings)); zombies_hit = groupcollide(zombies, bullets, False, False); #zombies_hit = dictionary of sprites; bullets will go straight through the zombies if both are false # print zombies_hit for zombie in zombies_hit: #empty dictionary - zombies are objects put in zombies list (.add() above) # print zombie; if zombie.yard_row == zombies_hit[zombie][0].yard_row: # print "Same row!"; bullets.remove(zombies_hit[zombie][0]); zombie.hit(1); #calling the zombie's local hit method - passed 1 damage - .hit adjusts their health if (zombie.health <= 0): zombies.remove(zombie); #removes zombie from game game_settings.zombie_in_row[zombie.yard_row] -= 1; #removes the 1 zombie from the row as its' killed - plant will keep shooting until # of zombies in row = 0 gf.update_screen(screen, game_settings, background, zombies, squares, plants, bullets, tick); pygame.display.flip();
def game_loop():
"""Internal game loop function that has access to clock, screen, etc."""
player = Player()
asteroid_cooldown = 0
while player:
for event in get_events():
if event.type == QUIT:
raise SystemExit('Thanks for playing!')
laser_collide = groupcollide(player.lasers, Asteroid.group, True, True, collide_circle)
player_collide = spritecollide(player, Asteroid.group, True, collide_circle)
if player_collide:
Asteroid.number_destroyed -= 1
player.kill()
player = None
if asteroid_cooldown <= 0:
# Spawn a new asteroid at a random point on the
# border of the screen, at a random angle and speed
x = 0
y = 0
side = randrange(1, 4)
if side == 1:
x = 0
y = randrange(0, SCREEN_HEIGHT)
if side == 2:
x = randrange(0, SCREEN_WIDTH)
y = 0
if side == 3:
x = SCREEN_WIDTH
y = randrange(0, SCREEN_HEIGHT)
if side == 4:
x = randrange(0, SCREEN_WIDTH)
y = SCREEN_HEIGHT
angle = randrange(0, 360)
speed = randrange(1, 5)
asteroid = Asteroid(3, speed, angle, pos=(x, y))
asteroid_cooldown = 450
# Draw the background to the screen
screen.blit(background, (0, 0))
# Draw score in top left
text = font.render(str(Asteroid.number_destroyed), 1, COLOR.WHITE)
screen.blit(text, (10, 10))
# Update all entities and draw them
Entity.group.update()
Entity.group.draw(screen)
# Display what has been drawn
display.update()
asteroid_cooldown -= 1
# Advance the clock
clock.tick(FPS)
def update(self):
sprite_dict = groupcollide(self.__bullets, self.__dvd_logos, False,
True)
self.__bullets.remove(*sprite_dict.keys())
self.__dvd_logos.remove(
*sprite_dict.keys()) # THIS SHOULDN'T LOOK LOOK LIKE THIS !!!
def update(self, player: PlayerSprite, screen: Surface):
# enemies need reference to other enemies and the player
self._enemies.update(player, self._enemies, screen)
hit = sprite.groupcollide(
self._enemies, player._weapon._bullets, False, True, lambda sp1,
sp2: not sp1._data.invulnerable and sprite.collide_mask(sp1, sp2))
for enemy in hit:
enemy.take_damage(player._damage)
def detect_collision(self):
if self.elements['ship'].sprite:
self.ship_collides = spritecollideany(self.elements['ship'].sprite,
self.elements['asteroids'])
if groupcollide(self.elements['lasers'], self.elements['asteroids'],
True, True):
self.score_add(50)
def update(self, ms):
game_objects = self.game_objects
game_objects.update(ms)
collisions = groupcollide(game_objects, game_objects, False, False)
for key, value in collisions.items():
value.pop(0)
if value:
key.collide(value)
def contact(self, hostile_fire):
"""Detect collision between player's and hostile fire.
hostile_fire: hostile Swarm of projectiles"""
for enemy_projectile in sprite.groupcollide(
hostile_fire, self, True, True,
collided=sprite.collide_circle):
hostile_fire.increase_score(SCORE_DESTROY_ENEMY *
enemy_projectile.n * 2)
def run_game():
# Init all the pygame stuff
pygame.init()
# set up a tuple for a screen size (horizontal, vertical)
screen_size = (1000, 800)
# tuple for background color (R, G, B)
background_color = (82, 111, 53)
# create a pygame to us
screen = pygame.display.set_mode(screen_size)
# set a caption on the terminal window
pygame.display.set_caption("3rd Person Shooter")
the_shooter = Player(screen, './images/Hero.png', 100, 100)
the_shooter_group = Group()
the_shooter_group.add(the_shooter)
bad_guy = Enemy(screen)
enemies = Group()
enemies.add(bad_guy)
bullets = Group()
tick = 0
# Main game loop run forever...(or until break)
# could also use Boolean instead of 1...
while 1:
tick += 1
if tick % 40 == 0:
enemies.add(Enemy(screen))
screen.fill(background_color)
check_events(the_shooter, screen, bullets)
# Draw the shooter
for shooter in the_player_group:
the_shooter.draw_me()
for bad_gu in enemies:
bad_guy.update_me(the_shooter)
bad_guy.draw_me()
hero_died = groupcollide(the_shooter_group, enemies, True, False)
bullet_hit = groupcollide(bullets, enemies, True, True)
print bullet_hit
# clear the screen for the next time throught the loop
pygame.display.flip()
def check_for_collisions(self):
# check for collisions between enemies and player bullets
# and increasing the score in case of a collision
if groupcollide(bullets, enemy_sprites, True, True):
ENEMY_EXPLOSION.play()
self.score += SCORE_PER_KILL
# check for collisions between enemies and player and
# decreasing player lives in case of a collision
if groupcollide(player_sprite, enemy_sprites, False, True):
self.player_lives -= 1
# ending the game if player is out of lives
if self.player_lives == 0:
self.player.kill()
PLAYER_EXPLOSION.play()
self.playing = False
else:
PLAYER_CRASH.play()
def detectCollisionSpellBound(self,spellGroup, boundGroup):
#kolizia spellov s hranicami ak prekroci hranicu vymaze spellu
spellsInBound = sprite.groupcollide(spellGroup, boundGroup, False, False)
if spellsInBound is not None:
for spell in spellsInBound:
if not (isinstance(spell,Spell.AoeSpell) or isinstance(spell,Spell.ShieldSpell)):
spell.kill()
def detect_collision(self):
if self.elements['ship'].sprite:
self.ship_collides = spritecollideany(self.elements['ship'].sprite, self.elements['asteroids'])
self.ship_catches = spritecollide(self.elements['ship'].sprite, self.elements['power-ups'], True)
if groupcollide(self.elements['lasers'], self.elements['asteroids'], True, True):
if randint(1, 20) == 1:
self.newPU = True
self.score_add(50)
def update(self):
self.spawnticker += 1
"""
if self.spawnticker >= self.spawntime:
#print "ICE SPAWNED"
self.meteors.add(RadiationMeteor((randrange(0,800),randrange(0,600)),self.bounds, 90, "radiation"))
self.meteors.add(IronMeteor((randrange(0,800),randrange(0,600)),self.bounds, 300, "iron"))
if self.spawnticker >= self.spawntime:
#print "spawned!"
self.meteors.add(RockMeteor((randrange(0,800),randrange(0,600)),self.bounds, 90, "rock"))
self.spawnticker = 0
"""
# update
self.MeteorSpawner.spawn()
self.meteors.update()
ImpactGroup.impacts.update()
self.player.update()
ShieldGroup.shields.update()
FallingGroup.fallings.update()
RoboGroup.robosprites.update()
PlayerSprite.sprite.update()
DebrisGroup.debris.update()
self.timer += 1
# collisions
coll = groupcollide(self.player_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
coll = groupcollide(self.robot_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
num_alive = 0
for robot in self.robot_grp:
if not robot.alive():
num_alive += 1
self.player.lives -= num_alive - self.deadcount
self.deadcount = num_alive
def hit(self, target: Wave) -> None:
"""Detect collision between projectiles and their target.
Colliding projectiles get killed off (dokill2=True), target takes damage.
target: Wave of spaceship(s)"""
for ship in sprite.groupcollide(target, self, False, True,
sprite.collide_circle):
ship.damage()
target.increase_score(SCORE_HULL_DAMAGE * ship.n)
if ship.is_destroyed:
target.increase_score(SCORE_DESTROY_ENEMY * ship.n)
def check_colision_virus4(miras, viroses, estado_jogo, pontuacao_placar,
ai_settings, barra_tempo):
colidir = groupcollide(miras, viroses, False, True)
if colidir:
estado_jogo.pontos += (ai_settings.fator_base_pontos *
ai_settings.speed4)
if barra_tempo.tamanho_barra + 50 < barra_tempo.tamanho_maximo:
barra_tempo.tamanho_barra += 50
elif barra_tempo.tamanho_barra + 50 > barra_tempo.tamanho_maximo:
barra_tempo.tamanho_barra = barra_tempo.tamanho_maximo
def handle_event(self, event):
if event.type == KEYDOWN and event.key == K_ESCAPE:
self.app.set_state(PauseMenu)
elif event.type == KEYDOWN and event.key == K_SPACE and not self.is_gameover():
if self.player.carrying:
self.player.drop()
else:
for robot in groupcollide(self.robot_grp, self.player_grp, False, False):
self.player.grab(robot)
self.score += 50
print "robot picked up"
def update(self, ms):
game_objects = self.game_objects
game_objects.update(ms)
collisions = groupcollide(game_objects, game_objects, False, False)
for key, value in collisions.items():
value.pop(0)
if value:
try:
key.collide(value)
except AttributeError:
pass
def collisions():
"""Does collision detection for all sprites.
Currently handles: player/bullet, enemy/bullet, bullet/bullet
"""
global lives, score, player
#player with enemy bullets
if spritecollide(player, evil_bullets, True, collide_mask):
lives -= 1
player = Player(window_size, ship_filename, ship_speed)
#enemies with player bullets
#currently rather lazy because there's only ever one player bullet
if groupcollide(good_bullets, enemy_wave, True, True, collide_mask):
score += enemy_kill_pts
#enemy bullets with player bullets
#currently rather lazy because there's only ever one player bullet
if groupcollide(good_bullets, evil_bullets, True, True, collide_mask):
score += bullet_kill_pts
def update(self):
self.player.update()
self.npcgroup.update()
if sprite.spritecollideany(self.player, self.walls):
self.player._goback()
for npc in sprite.groupcollide(self.npcgroup, self.walls, False, False):
npc._goback()
npcCollisions = sprite.spritecollide(self.player, self.npcgroup, False)
if len(npcCollisions) > 0:
self.prepareForBattle()
npcCollisions[0].kill()
return BattleEvent(self.player, npcCollisions[0])
return None
def play(self):
# this line may need moving
self.done = False
self.clock = pygame.time.Clock()
print "Loop Started"
while not self.done: # MAIN WHILE LOOP
#input
self.input()
#spawn meteors
self.spawnticker += 1
if self.spawnticker >= self.spawntime:
print "ICE SPAWNED"
self.meteors.add(Meteor((randrange(0,800),randrange(0,600)),self.bounds, 90, "ice"))
if self.spawnticker >= self.spawntime:
#print "spawned!"
self.meteors.add(Meteor((randrange(0,800),randrange(0,600)),self.bounds, 90, "rock"))
self.spawnticker = 0
#update
self.meteors.update()
ImpactGroup.impacts.update()
self.player.update()
#collisions
coll = groupcollide(self.player_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
coll = groupcollide(self.robot_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
self.draw()
def handle_collisions(self):
hit = groupcollide(self.projectiles, self.enemies, True, False)
for _, enemies in hit.items():
for enemy in enemies:
if enemy.hit(self.player.weapon_power):
self.current_wave.on_ship_destroyed(enemy)
player_hit = spritecollide(self.player, self.enemy_projectiles, True)
if len(player_hit) > 0:
self.game.events.broadcast('PLAYER_HIT',
{'damage': player_hit[0].power})
def run_game(): tick = 0; while 1: gf.check_events(screen,game_settings, squares, plants,bullets,icons); if game_settings.game_active: tick += 1; if tick % 10 == 0: zombies.add(Zombie(screen,game_settings)); zombies_hit = groupcollide(zombies, bullets, False, False); # print zombies_hit; for zombie in zombies_hit: # print zombie; # print zombies_hit[zombie]; if zombie.yard_row == zombies_hit[zombie][0].yard_row: # print "Same row!!!"; bullets.remove(zombies_hit[zombie][0]); zombie.hit(1); if(zombie.health <= 0): zombies.remove(zombie); game_settings.zombie_in_row[zombie.yard_row] -= 1; game_settings.zombies_killed += 1; zombies_eating = groupcollide(zombies,plants,False,False); for zombie in zombies_eating: damaged_plant = zombies_eating[zombie][0] if zombie.yard_row == damaged_plant.yard_row: # zombie has hit a plant in it row zombie.moving = False; if time.time() - zombie.started_eating > zombie.damage_time: zombie.zombie_chomp(damaged_plant) zombie.started_eating = time.time(); if damaged_plant.health <= 0: plants.remove(damaged_plant); zombie.moving = True; gf.update_screen(screen,game_settings,background,zombies,squares,plants,bullets,tick,icons); pygame.display.flip();
def run_game():
tick = 0 # each tick a screen reload
while 1:
gf.check_events(screen, game_settings, squares, plants, bullets, icons)
if game_settings.game_active:
tick += 1
if tick % 30 == 0: # every 30 seconds, add a zombie to the game
zombies.add(Zombie(screen, game_settings))
zombies_hit = groupcollide(zombies, bullets, False, False)
for zombie in zombies_hit:
if zombie.yard_row == zombies_hit[zombie][0].yard_row:
bullets.remove(zombies_hit[zombie][0])
zombie.hit(1)
if zombie.health <= 0:
zombies.remove(zombie)
game_settings.zombie_in_row[zombie.yard_row] -= 1
game_settings.zombies_killed += 1
zombies_eating = groupcollide(zombies, plants, False, False)
for zombie in zombies_eating:
damaged_plant = zombies_eating[zombie][0]
print damaged_plant
if zombie.yard_row == damaged_plant.yard_row:
zombie.moving = False
if time.time(
) - zombie.started_eating > zombie.damage_time:
print "Zombie took a bite"
damaged_plant.take_damage(2)
zombie.started_eating = time.time()
if damaged_plant.health <= 0:
plants.remove(damaged_plant)
zombie.moving = True
damaged_plant.square.plant_here = False
gf.update_screen(screen, game_settings, background, zombies, squares,
plants, bullets, tick, icons)
pygame.display.flip()
def handle_event(self, event):
if event.type == KEYDOWN and event.key == K_ESCAPE:
self.app.set_state(PauseMenu)
elif event.type == KEYDOWN and event.key == K_SPACE:
if self.player.carrying:
self.player.drop()
else:
for robot in groupcollide(self.robot_grp, self.player_grp, False, False):
self.player.grab(robot)
self.score += 50
print "robot picked up"
if self.player.lives <= 0 and self.player.health <= 0:
self.app.set_state(GameOver)
def callback(group) -> Dict:
def _collided(sprite1, sprite2):
x1, y1 = sprite1.rect.topleft
x2, y2 = sprite2.rect.topleft
x0, y0 = offset
positional_offset = (x2 - x1 - x0, y2 - y1 - y0)
overlap = sprite1.mask.overlap(sprite2.mask, positional_offset)
return bool(overlap)
collision_dict = sprite.groupcollide(group, self, False, False,
_collided)
return collision_dict
def everytime(self):
# Delete the sprites that are unable to .everytime()
for gobj in self.ginfo.sprites():
if not gobj.everytime():
self.ginfo.remove(gobj)
# Let the players be blocked by the blocking
hitdict = sprite.groupcollide(self.getall(IPlayer), self.getall(IBlocking), False, False).items()
for player, block in hitdict:
player.blocked(block)
# Let the shootables be shot by the projectiles
hitdict = sprite.groupcollide(self.getall(IShootable), self.getall(IProjectile), False, True).items()
for shootable, projectile in hitdict:
shootable.hit(projectile)
# Remove the moveables that are off the screen
for moveable in self.getall(IMoveable).sprites():
x, y, w, h = moveable.rect
if x < 0 or (x + w) > RES[0] or y < 0 or (y + h) > RES[1]:
self.ginfo.remove(moveable)
return True
def attCollide(self, attackGroup, victimGroup):
"""
Uses pygame collision to collide two sprite groups.
Then hits the victim group with each collided attack.
"""
if len(attackGroup) > 0:
collDict = sprite.groupcollide(
attackGroup,
victimGroup,
False,
False)
for atk in collDict.keys():
for victim in collDict[atk]:
victim.hit(atk)
def input(self): for event in pygame.event.get(): if event.type == QUIT: self.quit() elif event.type == KEYDOWN and event.key == K_ESCAPE: self.quit() elif event.type == KEYDOWN and event.key == K_SPACE: if self.player.carrying: self.player.drop() else: for robot in groupcollide(self.robot_grp, self.player_grp, False, False): self.player.grab(robot) self.score += 5 print "robot picked up" break
def collisions(self):
"""Handles collisions
"""
player = self.player
enemy = self.enemy
shield = self.shield
hbullet = self.hbullet
cannon = self.cannon
ion_field = self.ion_field
player_bullets = self.player_bullets
#player with homing bullet
if collide_mask(player, hbullet) and not collide_mask(player, ion_field):
self.kill_player()
#player with enemy base
if collide_mask(player, enemy):
#if base in moving phase, give player energy
if enemy.get_state_number() == EnemyBase.MOVING:
self.manager.give_energy(opt.energy_from_enemy)
#if base in spinning or shooting phase, kill player
elif enemy.get_state_number() == EnemyBase.SPINNING:
self.kill_player()
elif enemy.get_state_number() == EnemyBase.SHOOTING:
self.kill_player()
#player with cell
#-hitting a cell will bounce the player a bit to the left
#-if the player hit the cell twice in a short enough span,
# the cell is eaten and the player gets energy
#-in case of multiple collisions, deal with cell closest to player's center
#
#TODO: This still isn't quite right.
#Should be able to eat top/bottom rows with diagonal movement.
#(vertical movement should still move player all the way left)
pc_collides = spritecollide(player, shield, False, collide_mask)
center_cell = self.find_centermost_cell(pc_collides)
if center_cell is not None:
player.rect.right = center_cell.rect.left - opt.cell_bounceback
if not center_cell.marked:
center_cell.mark()
elif shield.can_eat():
center_cell.kill()
self.manager.give_energy(opt.energy_from_cell)
self.manager.add_score(opt.score_cell_eat)
shield.start_delay(opt.frames_to_eat_cell)
#player with cannon
if collide_mask(player, cannon):
#if in deactivated phase, try spending required energy to activate
if (cannon.get_state_number() == Cannon.DEACTIVATED and
self.manager.spend_energy(opt.cannon_energy_cost)):
cannon.start_standby()
#if in firing phase, kill player
if cannon.get_state_number() == Cannon.FIRING:
self.kill_player()
#if in returning phase, give energy and deactivate cannon
if cannon.get_state_number() == Cannon.RETURNING:
cannon.start_transition(Cannon.DEACTIVATED)
self.manager.give_energy(opt.energy_from_cannon)
#cannon with cell
#kill one cell and reverse cannon direction
#assuming this is only possible if cannon in firing state
if cannon.get_state_number() == Cannon.FIRING:
cannon_collides = spritecollide(cannon, shield, False, collide_mask)
if len(cannon_collides) > 0:
cannon_collides[0].kill()
self.manager.add_score(opt.score_cell_shoot)
cannon.start_transition(Cannon.RETURNING)
#cannon with enemy base -- only if cannon in firing state
#give points corresponding to enemy state and end level
#if enemy base is in shooting state, player also gets a life
if cannon.get_state_number() == Cannon.FIRING and collide_mask(cannon, enemy):
if enemy.get_state_number() == EnemyBase.MOVING:
self.manager.add_score(opt.score_mover_destroy)
elif enemy.get_state_number() == EnemyBase.SPINNING:
self.manager.add_score(opt.score_spinner_destroy)
elif enemy.get_state_number() == EnemyBase.SHOOTING:
self.manager.add_score(opt.score_shooter_destroy)
self.manager.give_life()
self.end_level()
#player's bullet with cell
#kill player bullet but remove cells in a cross pattern
#if somehow one bullet hits multiple cells one is arbitrarily selected
bc_collides = groupcollide(player_bullets, shield, True, False, collide_mask)
for current_bullet in bc_collides.keys():
self.manager.add_score(opt.score_cell_shoot)
shield.remove_cross(bc_collides[current_bullet][0])
def main():
#initialize pygame
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
#initialize game
Player = Player(bounds.center, bounds) #sets starting position fir player
player_grp = GroupSingle(player)
enemies = Group()
spawn_counter = 0
fast_spawn_counter = 0
score = 0
font = pygame.font.Font(None, 40)
#game loop
done = False
clock = pygame.time.Clock()
while not done:
#input
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
elif event.type == MOUSEBUTTONDOWN and event.button == 1: #1=left mouse button
player.shoot()
elif event.type == KEYDOWN and event.key == K_SPACE and not player.alive(): #if player dies, hit space and game restarts
player = Player(bounds.center,bounds)
player_grp.add(player)
for enemy in enemies:
enemy.kill() #same as enemies.empty()
#update
player_grp.update()
player.bullets.update()
enemies.update()
#spawn enemies
spawn_counter+=1
if spawn_counter >= 10:
n = randrange(4)
for i in range(n):
x = randrange(bounds.width - Enemy.width)
enemy = Enemy((x,0),bounds)
enemies.add(enemy)
spawn_counter = 0 #reset counter afer
#spawn fast enemy
fast_spawn_counter += 1
if fast_spawn_counter >= 45:
x = randrange(bounds.width - FastEnemy.width)
enemy = FastEnemy((x,0),bounds)
enemies.add(enemy)
fast_spawn_counter = 0
#collisions - see pygame documentation
groupcollide(player_grp, enemies, True, False) #if enemies hit player, player dies
#if bullets hit enemies, enemy dies
#score keeper
for enemy in groupcollide(enemies, player.bullets, True, True):
if player.alive():
score+=1
#draw
screen.fill(BG_COLOR)
player_grp.draw(screen)
player.bullets.draw(screen)
enemies.draw(screen)
score_text = font.render("Score: %08d"%score, False, (255,255,255))
screen.blit(score_text, (5,5))
pygame.display.flip()
clock.tick(30)
DISPLAYSURF.blit(rotatedSurf, rotatedRect) #wyswietlamy obrocona armate
# Tworzenie gracza, dodanie go do listy spriteow
player = Target(pygame.mouse.get_pos())
all_sprites_list.add(player)
# Sprawdzanie kolizji gracz <-> kula
hit_list = pygame.sprite.spritecollide(player, bullets_list, True) #w hit_list przechowaj sprity kolizyjne. Wartosc True oznacza, ze znikna z ekranu po kolizji.
for bullet in hit_list: #dla wszystkich kul armatnich, ktore trafily w gracza
hits += 1 #zwieksz wartosc zmiennej hits o 1
openChannel_A = pygame.mixer.find_channel() #znajdz wolny kanal
if openChannel_A: #jezeli kanal jest wolny
openChannel_A.play(player.effect) #odegraj dzwiek odgrywany po zderzeniu
# Sprawdzanie kolizji kula <-> kula
if groupcollide(bullet1_list, bullet2_list, True, True):
boom = pygame.mixer.Sound('bomb.wav')
boom.set_volume(.5)
openChannel_B = pygame.mixer.find_channel()
if openChannel_B:
openChannel_B.play(boom)
# Rysujemy ramke planszy o grubosci 1
pygame.draw.rect(DISPLAYSURF, BLACK, (0, 0, WINDOWWIDTH, WINDOWHEIGHT), 1)
# Rysujemy wszystkie obiekty Sprite - kule armatnie i gracza
if koniec == 0:
all_sprites_list.draw(DISPLAYSURF)
# Wyswietlamy instrukcje dla gracza w dolnej czesci ekranu
if koniec == 0:
score = font.render("Score: " + str(player.score), 1, WHITE_COLOR)
lives = font.render("Lives: " + str(player.lives), 1, WHITE_COLOR)
screen.blit(score, score.get_rect())
screen.blit(lives, (screen.get_width() / 2, 0))
# Enemies movement
zerglings.draw(screen)
ship.draw(screen)
bullet.draw(screen)
# for zerg in zerglings:
# screen.blit(zerg.image, zerg.position)
# Ship movement
#screen.blit(ship.image, ((ship.position[0] - ship.image.get_width() / 2),
# ship.position[1]))
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
ship.update(event, bullet)
bullet.update()
kill_list = sprite.groupcollide(bullet, zerglings, True, True)
for val in kill_list.values():
for x in val:
player.add_pointes(x.points)
pygame.display.update()
def main():
#initialize pygame
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
spawntime = 60
spawnticker = 0
fast_spawn_counter = 0
score = 0
#initialize the game
player = Player(bounds.center, bounds) #creates a new player object, passes variables to it.
player_grp = GroupSingle(player)
enemies = Group() #emtpy sprite group
font = pygame.font.Font(None, 40)
#game loop
done = False
clock = pygame.time.Clock()
while not done:
#input
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
elif event.type == MOUSEBUTTONDOWN and event.button == 1:
player.shoot()
elif event.type == KEYDOWN and event.key == K_SPACE and not player.alive():
player = Player(bounds.center, bounds) # respawns player
player_grp.add(player)
score = 0
for enemy in enemies:
enemy.kill()
# can also do enemies.empty()
#update
player_grp.update() #only if the player is in the player_grp sprite group. See destroyed area
player.bullets.update() #update everything in the Bullets list
enemies.update()
#collisions
groupcollide(player_grp, enemies, True, False) #first group, second group, then which gets killed
for enemy in groupcollide(enemies, player.bullets, True, True):
if player.alive():
score +=1 #counts how many are intersecting
#spawn
spawnticker += 1
if spawnticker >= spawntime:
#print "spawned!"
enemies.add(Enemy((randrange(0,400),randrange(0,200)),bounds))
spawnticker = 0
fast_spawn_counter += 1
if fast_spawn_counter >= 45:
#print "spawned!"
x = randrange (0, 480)
enemy = FastEnemy((x,0), bounds)
enemies.add(enemy)
fast_spawn_counter = 0
#draw
screen.fill(BG_COLOR) # fill then draw
player.bullets.draw(screen) #bullets is the list of all bullets
player_grp.draw(screen)
enemies.draw(screen)
score_text = font.render("Score: %08d" %score, False, (255,255,255))
screen.blit(score_text, (5,5))
pygame.display.flip()
clock.tick(30)
def get_collided(self, group):
return sprite.groupcollide(self, group, False, False)
def main():
# initialze pygame
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
# initialize the game
player = Player(bounds.center, bounds)
player_grp = GroupSingle(player)
enemies = Group()
spawn_counter = 0
fast_spawn_counter = 0
score = 0
font = pygame.font.Font(None, 40)
# game loop
done = False
clock = pygame.time.Clock()
while not done:
# input
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
elif event.type == MOUSEBUTTONDOWN and event.button == 1:
player.shoot()
elif event.type == KEYDOWN and event.key == K_SPACE and not player.alive():
player = Player(bounds.center, bounds)
player_grp.add(player)
score = 0
for enemy in enemies:
enemy.kill()
# same as enemies.empty()
# update
player_grp.update()
player.bullets.update()
enemies.update()
# spawn enemies
spawn_counter += 1
if spawn_counter >= 10:
n = randrange(4)
for i in range(n):
x = randrange(bounds.width - Enemy.width)
enemy = Enemy((x, 0), bounds)
enemies.add(enemy)
spawn_counter = 0
# fast spawn
fast_spawn_counter += 1
if fast_spawn_counter >= 45:
x = randrange(bounds.width - FastEnemy.width)
enemy = FastEnemy((x, 0), bounds)
enemies.add(enemy)
fast_spawn_counter = 0
# collisions
groupcollide(player_grp, enemies, True, False)
for enemy in groupcollide(enemies, player.bullets, True, True):
if player.alive():
score += 1
# draw
screen.fill(BG_COLOR)
player_grp.draw(screen)
player.bullets.draw(screen)
enemies.draw(screen)
score_text = font.render("Score: %08d"%score, False, (255, 255, 255))
screen.blit(score_text, (5, 5))
if not player.alive():
gameover = font.render("Press Space to Respawn", False, (255, 255, 255))
rect = gameover.get_rect()
rect.center = screen.get_rect().center
screen.blit(gameover, rect)
pygame.display.flip()
clock.tick(30)
def update(self, time):
self.l_interval = self.l_interval + .01
if self.l_interval >= 4 * math.pi:
self.l_interval = 0.0
self.time += time
while self.time > G.Globals.INTERVAL:
self.time -= G.Globals.INTERVAL
curr_enemies = PS.Group()
for i, e in enumerate(self.enemies.sprites()):
dead, bull = e.update(G.Globals.INTERVAL, self.player,
self.map, self.enemies.sprites(), i)
if dead:
self.enemies.remove(e)
if self.map.boss_coord is not None:
Game.SCORE += 500
G.new_level(self.player)
return
elif not (e.rect.x < - e.rect.width or e.rect.x > G.Globals.WIDTH + e.rect.width \
or e.rect.y < -e.rect.height or e.rect.y > G.Globals.HEIGHT + e.rect.height):
curr_enemies.add(e)
if bull is not None:
self.e_bullets.add(bull)
for b in self.bullets.sprites():
if b.update(G.Globals.INTERVAL):
self.bullets.remove(b)
for b in self.e_bullets.sprites():
if b.update(G.Globals.INTERVAL):
self.e_bullets.remove(b)
for blood in self.blood:
blood.update(G.Globals.INTERVAL)
if blood.gone:
self.blood.remove(blood)
for stain in self.blood_stains:
stain.update()
for heart in self.hearts_group.sprites():
heart.update()
self.player.update(G.Globals.INTERVAL)
self.set_screen_cords_player()
#self.collision(curr_enemies, self.bullets, self.e_bullets, self.player_group, self.wall_sprites_list)
# Are there collisions
# Player Collision with walls
result = PS.groupcollide(self.player_group, self.wall_sprites_list,
False, False)
for key in result:
for wall in result[key]:
if self.player.rect.colliderect(wall.rect):
val = self.player.wall_collision(wall, self.map)
self.set_screen_cords_player()
if val == 1:
self.wall_sprites_list.remove(wall)
if val == 2:
Game.SCORE += 100
G.new_level(self.player)
# Player collision with enemies
result = PS.groupcollide(self.player_group, curr_enemies,
False, False)
for key in result:
for enemy in result[key]:
if enemy.dying is False and self.player.take_damage(1):
G.Globals.STATE = GameOver.GameOver(False, Game.SCORE)
# Player collision with enemy bullets
result = PS.groupcollide(self.player_group, self.e_bullets, False,
False)
for player in result:
if self.player.take_damage(1):
G.Globals.STATE = GameOver.GameOver(False, Game.SCORE)
blood_x = player.world_coord_x + Player.Player.WIDTH / 2
blood_y = player.world_coord_y + Player.Player.HEIGHT / 2
self.blood.append(Blood.Blood(blood_x,
blood_y, .8))
p_width = Player.Player.WIDTH
p_height = Player.Player.HEIGHT
self.blood_stains.append(BloodStain.BloodStain(blood_x,
blood_y,
p_width,
p_height))
for bullet in result[player]:
self.e_bullets.remove(bullet)
# Enemy Collision with Bullets
result = PS.groupcollide(curr_enemies, self.bullets, False, False)
for enemy in result:
if enemy.dying is True:
continue
if self.double_kill is False:
self.double_kill = True
self.double_kill_timer = 0
self.last_killed = enemy
if self.double_kill_timer < Game.DOUBLE_KILL_TIME and self.double_kill \
and self.last_killed is not enemy:
#Game.DOUBLE_KILL_SOUND.play()
self.double_kill = False
enemy.start_death()
blood_x = int(enemy.world_x + enemy.width / 2)
blood_y = int(enemy.world_y + enemy.height / 2)
self.blood.append(Blood.Blood(blood_x,
blood_y, .8))
self.blood_stains.append(BloodStain.BloodStain(blood_x,
blood_y,
enemy.width,
enemy.height))
Game.SCORE = Game.SCORE + 10
for bullet in result[enemy]:
if self.player.piercing is False and bullet.__class__.__name__ is not "Laser":
self.bullets.remove(bullet)
if random.random() < Game.HEALTH_DROP_RATE:
self.hearts_group.add(Heart.Heart(enemy.world_x,
enemy.world_y))
# Bullets Collide with Wall
result = PS.groupcollide(
self.bullets, self.wall_sprites_list, False, False)
for bullet in result:
if bullet.__class__.__name__ is not "Laser":
self.bullets.remove(bullet)
# Enemy Bullets Collide with Wall
result = PS.groupcollide(
self.e_bullets, self.wall_sprites_list, False, False)
for bullet in result:
self.e_bullets.remove(bullet)
# Player picking up hearts
if self.player.health < self.player.max_health:
heart = PS.spritecollideany(self.player, self.hearts_group)
if heart is not None:
self.hearts_group.remove(heart)
self.player.health += 1
if self.player.health > self.player.max_health:
self.player.health = self.player.max_health
if self.double_kill:
self.double_kill_timer += time
if self.double_kill_timer > Game.DOUBLE_KILL_TIME:
self.double_kill = False
def filter_collision(self, group):
# Check collision and remove squares from this group
# if collision is true
# TODO: use a collide function and pass as parameter to check
# indices instead of checking rects
sprite.groupcollide(self, group, True, False)
def main():
#initialize pygame
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
#initialize game
player = Player(bounds.center, bounds) #sets starting position fir player
robot = Robot((randrange(0,800),randrange(0,600)), bounds)
player_grp = GroupSingle(player)
#robot_grp = GroupSingle(robot)
robot_grp = Group()
robot_grp.add(Robot((randrange(0,800),randrange(0,600)), bounds))
robot_grp.add(Robot((randrange(0,800),randrange(0,600)), bounds))
robot_grp.add(Robot((randrange(0,800),randrange(0,600)), bounds))
meteors = Group()
impacts = Group()
score = 0
spawntime = 10
spawnticker = 0
font = pygame.font.Font(None,35)
#game loop
done = False
clock = pygame.time.Clock()
print "Loop Started"
while not done:
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
elif event.type == KEYDOWN and event.key == K_SPACE:
if player.carrying:
player.drop()
else:
for robot in groupcollide(robot_grp, player_grp, False, False):
player.grab(robot)
score += 5
print "robot picked up"
break
#input
#spawn meteors
spawnticker += 1
if spawnticker >= spawntime:
#print "spawned!"
meteors.add(Meteor((randrange(0,800),randrange(0,600)),bounds, 90, "rock"))
spawnticker = 0
#update
meteors.update()
ImpactGroup.impacts.update()
player.update()
#collisions
coll = groupcollide(player_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
coll = groupcollide(robot_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
#draw
screen.fill(BG_COLOR)
robot_grp.draw(screen)
ImpactGroup.impacts.draw(screen)
meteors.draw(screen)
player_grp.draw(screen)
robot_grp.draw(screen)
clock.tick(30)
score_text = font.render("Score: %05d"%score, False, (255,255,255))
screen.blit(score_text, (5,5))
pygame.display.flip()
def main():
""" Main Program """
pygame.init()
# Set the height and width of the screen
size = [constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
bounds = screen.get_rect()
pygame.display.set_caption("Super Alien Assault!")
# Load the sound mixer:
pygame.mixer.pre_init(44100, -16, 2, 2048)
# This is supposed to help stop sound lag
# Create the player
player = Player(bounds.center, bounds)
player_grp = GroupSingle(player)
# Create an enemy
enemies = pygame.sprite.Group()
# Create all the levels
lindex = random.randrange(3,9)
level_list = []
level_list.append(levels.Level_01(player))
level_list.append(levels.Level_02(player))
level_list.append(levels.Level_03(player))
for i in range(lindex):
level_list.append(levels.Level_01(player))
level_list.append(levels.Level_02(player))
level_list.append(levels.Level_03(player))
# Initialize variables
score = 0
spawn_counter = 0
tween_diff = 1
# Select the font to use
font = pygame.font.SysFont("calibri",48)
# Set the current level
current_level_no = 0
current_level = level_list[current_level_no]
# List of each block
block_list = pygame.sprite.Group()
# Set current level for player and inital x,y position
player.level = current_level
player.rect.x = 340
player.rect.y = 200
# Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
# Play "Hot Nights" by Beardmont / Three Chain Links
# Available under Creative Commons attribution license from:
# https://soundcloud.com/beardmont
pygame.mixer.music.load('HotNights.ogg')
pygame.mixer.music.set_endevent(pygame.constants.USEREVENT)
pygame.mixer.music.play()
# -------- Main Program Loop -----------
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
elif event.type == pygame.constants.USEREVENT:
# This event is triggered when the song stops playing.
#
# Next, play "Happiest Days" by Beardmont / Three Chain Links
# Available under Creative Commons attribution license from:
# https://soundcloud.com/beardmont
pygame.mixer.music.load('HappiestDays.ogg')
pygame.mixer.music.play()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
done = True
if event.key == pygame.K_q:
done = True
if event.key == pygame.K_LEFT:
player.go_left()
if event.key == pygame.K_RIGHT:
player.go_right()
if event.key == pygame.K_UP:
player.jump()
if event.key == pygame.K_SPACE:
player.shoot()
if event.key == pygame.K_r and not player.alive():
main()
elif event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT and player.change_x < 0:
player.stop()
if event.key == pygame.K_RIGHT and player.change_x > 0:
player.stop()
# Update items in the level
current_level.update()
player_grp.update()
player.bullets.update()
player.bulletcasings.update()
enemies.update()
# Messing around with easing the enemy spawn counter
# They should gradually trickle in at first and then build
# to a flood of enemies then recede kind of like a tide
spawn_counter += (101 - spawn_counter)*.1
if spawn_counter >= 100:
n = random.randrange(3)
for i in range(n):
x = random.randint(900, 1000)
y = random.randint(100, 520)
enemy = Enemy((x, y))
enemies.add(enemy)
spawn_counter = 0
# Collision between player and enemies results in player death
groupcollide(player_grp, enemies, True, False)
# Add 1 point to score for every enemy the player kills
for enemy in groupcollide(enemies, player.bullets, True, True):
if player.alive():
score += 1
# If the player gets near the right side, shift the world left (-x)
if player.rect.x >= 310:
diff = player.rect.x - 310
# add some tweening/easing for momentum
tween_diff += (diff - tween_diff)*.1
player.rect.x = 310
current_level.shift_world(int(-tween_diff))
# also adjust enemies and bulletcasings by the world shift
for enemy in enemies:
enemy.rect.x += (int(-tween_diff))
for bulletcasing in player.bulletcasings:
bulletcasing.rect.x += (int(-tween_diff))
# If the player gets near the left side, shift the world right (+x)
if player.rect.x <= 290:
diff = 290 - player.rect.x
# add some tweening/easing for momentum
tween_diff += (diff - tween_diff)*.1
player.rect.x = 290
current_level.shift_world(int(tween_diff))
# also adjust enemies and bulletcasings by the world shift
for enemy in enemies:
enemy.rect.x += (int(tween_diff))
for bulletcasing in player.bulletcasings:
bulletcasing.rect.x += (int(tween_diff))
# If the player gets to the end of the level, go to the next level
current_position = player.rect.x + current_level.world_shift
if current_position < current_level.level_limit:
player.rect.x = 120
if current_level_no < len(level_list)-1:
current_level_no += 1
current_level = level_list[current_level_no]
player.level = current_level
# ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
current_level.draw(screen)
player_grp.draw(screen)
player.bullets.draw(screen)
player.bulletcasings.draw(screen)
enemies.draw(screen)
# Blit the current score
score_text = font.render("Score: %08d"%score, True, constants.PEACH)
screen.blit(score_text, (5,5))
# If player dies, blit the respawn menu
if not player.alive():
gameover = font.render("Press R to Respawn or ESC to Quit", True, constants.PEACH)
rect = gameover.get_rect()
rect.center = screen.get_rect().center
screen.blit(gameover, rect)
# ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT
# Limit to 60 frames per second
clock.tick(60)
# Go ahead and update the screen with what we've drawn.
pygame.display.flip()
# Be IDLE friendly. If you forget this line, the program will 'hang'
# on exit.
pygame.quit()
def main():
spawntime = 60
spawnticker = 0
score = 0
#initialize pygame
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
font = pygame.font.Font(None,35)
meteors = Group()
impacts = Group()
#initialize game
player = Player(bounds.center, bounds) #sets starting position for player
player_grp = GroupSingle(player)
#game loop
done = False
clock = pygame.time.Clock()
print "Loop Started"
while not done:
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
elif event.type == KEYDOWN and event.key == K_y:
print ImpactGroup.impacts
#input
#spawn meteors
spawnticker += 1
if spawnticker >= spawntime:
#print "spawned!"
meteors.add(Meteor((randrange(0,400),randrange(0,200)),bounds, 90, "rock"))
spawnticker = 0
#update
player.update()
meteors.update()
ImpactGroup.impacts.update()
#collisions
coll = groupcollide(player_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0], coll[robot][0].kind) #ASK ABOUT EASIER WAY TO WRITE THIS
#robot.damage(robot[0], robot[0].kind)
#for robot in coll: #groupcollide(player_grp, ImpactGroup.impacts, False, False):
# for meteor in robot:
# print meteor
#robot.damage(meteor, meteor.kind)
#print robot
#print "Impact List:", groupcollide(player_grp, ImpactGroup.impacts, False, False)
# robot.damage(robot{)
#draw
screen.fill(BG_COLOR)
meteors.draw(screen)
ImpactGroup.impacts.draw(screen)
player_grp.draw(screen)
score_text = font.render("Score: %05d"%score, False, (255,255,255))
screen.blit(score_text, (5,5))
pygame.display.flip()
clock.tick(30)
