def __init__(self):
self._settings = GameSettings()
self.score_count = 0
self.can_pipe_move = True
self.is_game_over = False
pygame.init()
self.clock = pygame.time.Clock()
self.game_display = display.set_mode(
(self._settings.window_width, self._settings.window_height))
self.asset_factory = AssetFactory()
self._pipe_group = Group()
self._pipe_gaps = Group()
self._pipe_generator = PipeGenerator(self.asset_factory,
self._settings)
max_mum_pipes = int(
self._settings.window_width /
(self._settings.pipe_width + self._settings.pipe_distance))
self._max_num_pipe_parts = max_mum_pipes * PipeGenerator.NUM_PIPE_PARTS
self.__initialize_pipes__()
self.flappy_bird_img = self.asset_factory.create_flappy_bird_image(
BIRD_SIZE)
self.flappy_bird = FlappyBird(BIRD_START_POS, self.flappy_bird_img)
self.flappy_bird_group = GroupSingle(self.flappy_bird)
self.bg_img = self.asset_factory.create_bg(
self._settings.window_width, self._settings.window_height)
def fire(self, mouse_pos, collidables):
"""Fires A Projectile
:param mouse_pos: The mouse position used to calculate the angle to fire the projectile.
:param collidables: A list of objects a projectile can collide with.
"""
if not self.projectile:
if self.current_weapon == 'Arc Shot':
self.projectile = GroupSingle(Explosive(cycle(self.strips['magic']),
self.rect.midtop,
self.calc_angle(
mouse_pos),
collidables,
self.power,
8,
3))
else:
self.projectile = GroupSingle(Beam_Shot(cycle(self.strips['magic']),
self.rect.midtop,
self.calc_angle(
mouse_pos),
collidables,
self.power,
6,
2))
def run_game():
pygame.init()
settings = game_settings.Settings()
screen = pygame.display.set_mode(settings.resolution)
snake = Snake(screen, settings)
pygame.display.set_caption("Snake")
my_tail = []
x, y = gf.generate_randoms()
food = GroupSingle(Food(snake, screen, x, y))
tails = OrderedUpdates()
gf.initialise_snake(snake, screen, my_tail, tails, settings)
button = Play_button(screen, settings, "Play")
end_game_screen = EndGameScreen(screen, settings, "Game Over")
score = Score(screen, settings)
clock = pygame.time.Clock()
gametime = GTime(clock)
while True:
screen.fill(settings.bg_color)
score.draw_me()
gf.check_events(snake, food, screen, my_tail, tails, settings, button,
gf, end_game_screen, score, gametime)
if settings.game_active == False:
if gf.lose_condition_met(snake, settings, tails,
gametime) == False:
button.draw_me()
if settings.game_active == True:
snake.update()
tails.update()
snake.draw_me()
food.update()
clock.tick(10)
gametime.update()
print(gametime.time)
pygame.display.flip()
def prep_blue_boss_health(self):
"""Prepare to drawn blue boss track."""
self.boss_health = GroupSingle()
boss_health = BlueBossHealth(self.ai_settings, self.screen)
hp_image = boss_health.hp_images[self.blue_boss_hp]
boss_health.image = hp_image.copy()
boss_health.rect.x = 500
boss_health.rect.y = 50
self.boss_health.add(boss_health)
def prep_red_boss_health(self):
"""Prepare to drawn red boss health."""
self.boss_health = GroupSingle()
boss_health = RedBossHealth(self.ai_settings, self.screen)
hp_image = boss_health.hp_images[self.red_boss_hp]
boss_health.image = hp_image.copy()
boss_health.rect.x = 500
boss_health.rect.y = 50
self.boss_health.add(boss_health)
def game():
# init
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
clock = pygame.time.Clock()
dude = PlayerShip(260, 500, screen.get_rect())
dude_grp = GroupSingle(dude)
enemies = Group()
enemies.add(Burger(200, 200, screen.get_rect()))
enemies.add(Hotdog(100, 100, screen.get_rect()))
#loop
while True:
# input
for evt in pygame.event.get():
if evt.type == QUIT:
return
elif evt.type == KEYDOWN and evt.key == K_ESCAPE:
return
elif evt.type == KEYDOWN and evt.key == K_a:
dude.dx = -10
elif evt.type == KEYDOWN and evt.key == K_d:
dude.dx = 10
elif evt.type == KEYUP and evt.key == K_a and dude.dx == -10:
dude.dx = 0
elif evt.type == KEYUP and evt.key == K_d and dude.dx == 10:
dude.dx = 0
elif evt.type == KEYDOWN and evt.key == K_SPACE and dude.alive():
dude.shoot()
# update
clock.tick(FPS)
dude.update()
enemies.update()
dude.bullets.update()
pygame.sprite.groupcollide(enemies, dude.bullets, 1, 1)
pygame.sprite.groupcollide(dude_grp, enemies, 1, 0)
# draw
screen.fill(BLACK)
dude_grp.draw(screen)
enemies.draw(screen)
dude.bullets.draw(screen)
pygame.display.flip()
def runGame():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screenWidth, ai_settings.screenHeight))
pygame.display.set_caption("Alien Invasion")
clock = pygame.time.Clock()
# Play button
play_button = Button(ai_settings, screen, "Play Game")
high = highScore(ai_settings, screen, "High Score")
# game stats
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# ship and bullets
ship = Ship(ai_settings, screen)
bullets = Group()
# aliens and lasers
aliens = Group()
lasers = Group()
ufo = GroupSingle()
#Bunker
bunkers = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
startScreen = Start(ai_settings, screen)
soundFile = vlc.MediaPlayer("files/SpaceInvaders.mp3")
while True:
clock.tick(62)
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, bunkers, high, ufo)
if stats.game_active:
soundFile.play()
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, lasers, bunkers, ufo)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets, lasers, bunkers, ufo)
gf.fire_laser(ai_settings, screen, aliens, lasers)
gf.update_lasers(ai_settings, screen, stats, sb, ship, aliens,
bullets, lasers, bunkers, ufo)
gf.updateBunkers(bullets, lasers, bunkers, aliens)
gf.spawnUFO(ai_settings, screen, ufo)
gf.updateUFO(ai_settings, ufo)
gf.updateScreen(ai_settings, screen, stats, sb, ship, aliens,
bullets, play_button, lasers, bunkers, ufo)
elif not stats.game_active and not stats.menu:
gf.startGame(play_button, high, startScreen)
soundFile.stop()
elif stats.menu:
gf.printHighScores(screen)
soundFile.stop()
def __init__(self, title='Checkers', log_level=log.INFO, show_fps=False):
log.basicConfig(level=log_level)
self.show_fps = show_fps
self.window_title = title
self.game = Board(BOARD_DIM)
# Initialize Game Groups
self.brown_spaces = RenderUpdates()
self.pieces = RenderUpdates()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.screen = None
self.fps_clock = None
self.font = None
self.font_rect = None
self.background = None
self.background_rect = None
self.fps_text = None
self.fps_rect = None
self.winner_text = None
self.winner_rect = None
def clean_up():
'''
Deletes all blocks that were created.
@postcondition: No more objects of BLOCK_TYPE exist in memory.
'''
global blocks, block_buffer
blocks = get_empty_block_array()
block_buffer = GroupSingle(Sprite())
block_buffer.sprite.rect = Rect(0, 0, 0, 0)
_blocks_to_check.clear()
_blocks_to_clear.clear()
def __init__(self, title='Checkers', log_level=log.INFO, show_fps=False):
log.basicConfig(level=log_level)
self.show_fps = show_fps
self.window_title = title
self.game = Board(BOARD_DIM)
# Initialize Game Groups
self.brown_spaces = RenderUpdates()
self.pieces = RenderUpdates()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.screen = None
self.fps_clock = None
self.font = None
self.font_rect = None
self.background = None
self.background_rect = None
self.fps_text = None
self.fps_rect = None
self.winner_text = None
self.winner_rect = None
def __init__(self, display: Surface, event_system: EventSystem,
images_loader: ImagesLoader):
self.__display = display
self.__event_system = event_system
self.__background = images_loader.smoothscale(
images_loader.load_surface(
os.path.join('backgrounds', 'stars_blue.png')),
self.__display.get_size())
self.__display.blit(self.__background, (0, 0))
player = build_player_ship(self.__display.get_rect().center, (0, 0),
10, self.__event_system, images_loader)
self.__player_group = GroupSingle(player)
self.__sprites_group = Group(player)
def run_game():
pygame.init()
sk_settings = Settings()
background = pygame.image.load('images/freetileset/png/BG/BG.png')
background = pygame.transform.smoothscale(
background, (sk_settings.window_width, sk_settings.window_height))
screen = pygame.display.set_mode(
(sk_settings.window_width, sk_settings.window_height))
pygame.display.set_caption('Super Knight')
fps = pygame.time.Clock()
knight = Knight(sk_settings, screen)
sword_container = GroupSingle()
arrows_right = Group()
arrows_left = Group()
zombies_top = Group()
zombies_bottom = Group()
zombies_left = Group()
zombies_right = Group()
gf.populate_zombies(sk_settings, screen, zombies_top, zombies_bottom,
zombies_left, zombies_right)
while True:
# everything redrawn every loop before flip called.
# Step 1: Check for user input
gf.check_events(sk_settings, screen, knight, arrows_right, arrows_left,
sword_container)
# Step 2: Apply user input to game objects
knight.update()
gf.update_zombies(sk_settings, screen, knight, arrows_right,
arrows_left, zombies_top, zombies_bottom,
zombies_left, zombies_right)
gf.update_arrows(sk_settings, screen, knight, arrows_right,
arrows_left, zombies_top, zombies_bottom,
zombies_left, zombies_right)
gf.update_sword(sk_settings, screen, knight, sword_container,
zombies_top, zombies_bottom, zombies_left,
zombies_right)
# Step 3: Redraw changes to game objects on the screen
gf.update_screen(sk_settings, screen, knight, arrows_right,
arrows_left, fps, zombies_top, zombies_bottom,
zombies_left, zombies_right, background,
sword_container)
def __init__(self):
Application.__init__(self)
self.screenRect = self.screen.get_rect()
self.minDt = 200
self.enemyGroup = Group()
self.enemyGroup.add(BasicEnemy(100,100,0,1,self.screenRect,80))
self.bulletGroup = Group()
self.player = Player(self.screenRect)
self.playerGroup = GroupSingle(self.player)
self.playerWeaponType = 1
self.playerFired = False
self.playerMoveX = 0
self.playerMoveY = 0
self.playerMoveFlag = False
def __init__(self, background: Surface, statics: [GameObject],
dynamics: [GameObject], ui: [GameObject]):
self.background: Surface = background
# Cached background with every statics blighted on it
self.__background: Surface = None
# Objects that are not supposed to move and that will be blited onto the background only once
# but will still receive update()
self.statics: Group = Group(statics)
# Objects that will change appearance in some way and will be rendered individually
self.dynamics: ScrollGroup = ScrollGroup(GlobalSettings.RESOLUTION,
dynamics)
# Objects that are not supposed to live in world space but in camera space
self.ui: RenderUpdates = RenderUpdates(ui)
# Layers used for collision masks
self.layers: Dict[Layers, Group] = {
Layers.ENVIRONMENT: Group(),
Layers.PLAYER: GroupSingle(),
Layers.ENEMY: Group(),
Layers.PROJECTILE: Group()
}
self.__state_dirty: bool = True
def __init__ (self):
self.SCREEN_SIZE = SCREEN_SIZE
self.BG_COLOR = BG_COLOR
self.score = 0
self.spawntime = 10
self.spawnticker = 0
self.robot_grp = Group()
#initialize pygame
#initialize game
self.player = Player(self.bounds.center, self.bounds) #sets starting position fir player
robot = Robot((randrange(0,800),randrange(0,600)), self.bounds)
self.player_grp = GroupSingle(self.player)
#robot_grp = GroupSingle(robot)
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.meteors = Group()
self.impacts = Group()
self.play()
def run(self):
self.background_sound.set_volume(0.3)
self.background_sound.play(loops=-1)
background_filename = join('gfx', 'bg_big.png')
self.background = pygame.image.load(background_filename).convert()
self.elements['score'] = GroupSingle(ScoreSprite(self))
self.elements['exploding_asteroids'] = ExplodingAsteroidsGroup()
self.elements['lasers'] = Group()
self.elements['asteroids'] = AsteroidGroup(join('gfx', 'asteroid.png'),
self)
self.elements['ship'] = ShipGroup(
sprite=Ship(join('gfx', 'ship.png'), 48, 48, self))
while True:
self.player_input()
self.events()
if self.input.quit_pressed:
exit(0)
self.update()
self.draw()
self.detect_collision()
time_passed = self.clock.tick(30)
def __init__(self, title='Checkers', log_drag=False, show_fps=False, ip='127.0.0.1', port=5000, spectate=False):
self.game_running = True
self.player = None
self.log_drag = log_drag
self.show_fps = show_fps
self.window_title = title
self.game = NetBoard(handler=self, ip=ip, port=port, spectate=spectate)
# Initialize Game Groups
self.board_spaces = set()
self.pieces = RenderUpdates()
self.piece_selected = GroupSingle()
self.bg_text = RenderUpdates()
self.fg_text = RenderUpdates()
self.current_piece_position = ORIGIN
self.screen = None
self.fps_clock = None
self.font = None
self.background = None
self.background_rect = None
self.fps_text = None
self.winner_text = None
self.turn_text = None
self.player_text = None
self.game_id_text = None
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 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()
class Player(Animated_Sprite):
"""Player class that the user will control.
:param sheet: The image used for the sprite sheet of player.
:param start_pos: Starting position for the Player.
:param name: String of the player name.
:param speed: Speed at which the player can move. Both horizontal and vertical.
"""
def __init__(self, sheet, start_pos, speed=4, power=30):
super(Player, self).__init__(sheet)
self.strips = {
'idle': self.sheet.load_strip(0, 6),
'magic': self.sheet.load_strip(3, 4),
'walking_r': self.sheet.load_strip(1, 6),
'walking_l': self.sheet.load_strip(2, 6)
}
self.curr_strip = self.strips['idle']
self.curr_anim = cycle(self.curr_strip)
self.image = self.curr_anim.next().copy()
self.mask = mask.from_surface(self.image)
self.rect = self.image.get_rect(midbottom=start_pos)
self.speed = speed
self.vel = Vector2(0, 0)
self.health = self.image.get_width()
self.projectile = None
self.power = power
self.current_weapon = 'Arc Shot'
def apply_damage(self, damage):
"""Has a player take damage.
:param damage: How much damage to take.
"""
self.health -= damage
if self.health <= 0:
self.kill()
def adjust_height(self, ground, xoffset):
"""Adjusts the height of the player to climb slopes.
:param ground: The surface the player is comparing to check if they are on a solid or not.
:param xoffset: How many pixels the player wants to move left or right.
"""
for i in range(1, self.speed + 1):
if not self.collide_ground(ground, (xoffset, -i)):
self.vel.y -= i
break
else:
self.vel.x = 0
def check_movement(self, ground, keys):
"""Perform actions based on what keys are pressed.
:param keys: The keys that are currently being pressed.
:param ground: The surface the player is walking on.
"""
if keys[K_a]:
self.transition('walking_l', ground, -self.speed)
elif keys[K_d]:
self.transition('walking_r', ground, self.speed)
else:
self.change_anim('idle')
if keys[K_SPACE]:
if not self.collide_ground(ground, (0, -self.speed)):
self.vel.y -= self.speed
if keys[K_1]:
self.current_weapon = 'Arc Shot'
elif keys[K_2]:
self.current_weapon = 'Beam Shot'
if keys[K_w] and self.power < 30:
self.power += 1
elif keys[K_s] and self.power > 10:
self.power -= 1
def collide_ground(self, ground, offset):
"""Returns the point of collision between player and ground with the given offset.
:param ground: Reference to ground.
:param offset: Tuple that offsets the player's mask.
"""
return ground.mask.overlap(self.mask,
(self.rect.left - ground.rect.left + offset[0],
self.rect.top - ground.rect.top + offset[1]))
def calc_angle(self, pos):
"""Helper function to calculate angle of trajectory for projectile.
:param pos: Position of mouse.
"""
(temp_x, temp_y) = self.rect.midtop
return atan2(temp_y - pos[1], temp_x - pos[0])
def change_anim(self, anim_name):
"""Changes the current animation to something different, for example, from idle to moving left or moving right to idle.
:param anim_name: The name of the animation to be set.
"""
if self.curr_strip is not self.strips[anim_name]:
self.curr_strip = self.strips[anim_name]
self.curr_anim = cycle(self.curr_strip)
def draw_health(self):
"""Draws the health bar.
"""
self.image.fill((255, 0, 0) if self.health < self.image.get_width() else (0, 255, 0),
((self.image.get_rect().topleft), (self.health, 4)))
def fire(self, mouse_pos, collidables):
"""Fires A Projectile
:param mouse_pos: The mouse position used to calculate the angle to fire the projectile.
:param collidables: A list of objects a projectile can collide with.
"""
if not self.projectile:
if self.current_weapon == 'Arc Shot':
self.projectile = GroupSingle(Explosive(cycle(self.strips['magic']),
self.rect.midtop,
self.calc_angle(
mouse_pos),
collidables,
self.power,
8,
3))
else:
self.projectile = GroupSingle(Beam_Shot(cycle(self.strips['magic']),
self.rect.midtop,
self.calc_angle(
mouse_pos),
collidables,
self.power,
6,
2))
def transition(self, new_anim, ground, dx):
"""Helper function for updating animation and movement in check_movement.
:param new_anim: New animation to set.
:param ground: The surface the player is walking on.
:param dx: Amount that the player will move on the next frame.
"""
self.change_anim(new_anim)
self.vel.x += dx
if self.collide_ground(ground, (dx, 0)):
self.adjust_height(ground, dx)
def update(self, world):
"""Update the Player
:param world: The world the player inhabits.
"""
super(Player, self).update()
self.draw_health()
if self.projectile:
self.projectile.update(world)
self.projectile.draw(world.image)
if not self.collide_ground(world.ground, (0, world.gravity)):
self.vel.y += world.gravity
self.rect.move_ip(self.vel)
self.vel = Vector2(0, 0)
self.rect.clamp_ip(world.rect)
class Game:
def __init__(self, title='Checkers', log_level=log.INFO, show_fps=False):
log.basicConfig(level=log_level)
self.show_fps = show_fps
self.window_title = title
self.game = Board(BOARD_DIM)
# Initialize Game Groups
self.brown_spaces = RenderUpdates()
self.pieces = RenderUpdates()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.screen = None
self.fps_clock = None
self.font = None
self.font_rect = None
self.background = None
self.background_rect = None
self.fps_text = None
self.fps_rect = None
self.winner_text = None
self.winner_rect = None
def _board_setup(self, **kwargs):
""" initialize board state """
brown_spaces = kwargs.get('brown_spaces')
for col, row in self.game.usable_positions():
loc = TILE_WIDTH * col + (BORDER_WIDTH / 2), TILE_WIDTH * row + (BORDER_WIDTH / 2)
brown_spaces.add(SquareSprite(loc, "brown", row, col))
def _screen_init(self):
""" Initialise screen """
pygame.init()
self.screen = pygame.display.set_mode(SCREEN_RES)
pygame.display.set_caption(self.window_title)
return self.screen
def _get_background(self):
result = pygame.Surface(self.screen.get_size())
(bg_img, bg_rect) = ImageLoader.load_img('marble-board.jpg')
result.blit(bg_img, bg_rect)
return result.convert(), bg_rect
def _get_fps_text(self):
fps_text = self.font.render("%4.1f fps" % self.fps_clock.get_fps(), True, WHITE)
rect = fps_text.get_rect()
rect.right, rect.bottom = self.background_rect.right, self.background_rect.bottom
return fps_text, rect
def _draw_fps(self):
if self.show_fps:
self.fps_text, self.fps_rect = self._get_fps_text()
self.screen.blit(self.fps_text, self.fps_rect)
def _clear_fps(self):
if self.show_fps:
self.screen.blit(self.background, self.fps_rect, area=self.fps_rect)
def _clear_items(self):
self._clear_winner()
self._clear_fps()
self.piece_selected.clear(self.screen, self.background)
self.pieces.clear(self.screen, self.background)
def _draw_winner(self):
winner = self.game.winner()
if winner:
self.winner_text = self.font.render("%s wins!" % winner.title(), True, WHITE)
winner_rect = self.winner_text.get_rect()
winner_rect.centerx = self.background.get_rect().centerx
winner_rect.top = 100
self.winner_rect = winner_rect
self.screen.blit(self.winner_text, winner_rect)
def _clear_winner(self):
winner = self.game.winner()
if winner:
self.screen.blit(self.background, self.winner_rect, area=self.winner_rect)
def _quit(self):
log.debug('quitting')
sys.exit()
def _select_piece(self, event):
# select the piece by seeing if the piece collides with cursor
self.piece_selected.add(piece for piece in self.pieces if piece.rect.collidepoint(event.pos))
# Capture piece's original position (at center) to determine move on drop
if len(self.piece_selected) > 0:
# Assumed: starting a move
pygame.event.set_grab(True)
self.pieces.remove(self.piece_selected)
self.current_piece_position = (self.piece_selected.sprite.rect.centerx,
self.piece_selected.sprite.rect.centery)
log.debug('grabbing input, picked up piece at %s', self.current_piece_position)
def _drag_piece(self):
# Until button is let go, move the piece with the mouse position
self.piece_selected.update(pygame.mouse.get_pos())
log.debug('updated piece to %s', pygame.mouse.get_pos())
def _drop_piece(self, event):
if pygame.event.get_grab():
pygame.event.set_grab(False)
log.debug('releasing input')
# center the piece on the valid space; if it is not touching a space, return it to its original position
self.space_selected.add(space for space in self.brown_spaces
if space.rect.collidepoint(event.pos))
if self.piece_selected and self.space_selected:
log.debug('dropped a piece')
piece, space = self.piece_selected.sprite, self.space_selected.sprite
try:
captured = self.game.move(piece.location, (space.col, space.row))
if captured:
self.pieces.remove(captured)
except InvalidMoveException as ce:
log.debug(ce)
log.debug("%s", str(self.game))
self.piece_selected.sprite.update_from_board()
# Add piece back to stationary set
self.pieces.add(self.piece_selected)
# clean up for the next selected piece
self.piece_selected.empty()
self.space_selected.empty()
def _draw_items(self):
self.pieces.draw(self.screen)
self.piece_selected.draw(self.screen)
self._draw_winner()
self._draw_fps()
def run(self):
log.debug('starting game')
log.debug('initializing screen')
self.screen = self._screen_init()
log.debug('getting font')
self.font = pygame.font.Font(None, 36)
log.debug('loading background')
self.background, self.background_rect= self._get_background()
log.debug('building initial game board')
self._board_setup(brown_spaces=self.brown_spaces)
log.debug('initializing game pieces')
for player, x, y in self.game.start_positions():
new_piece = PieceSprite(player)
self.game.add_piece(new_piece, (x, y))
new_piece.update_from_board()
self.pieces.add(new_piece)
log.debug('drawing initial content to screen')
self.screen.blit(self.background, ORIGIN)
pygame.display.flip()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.fps_clock = Clock()
self._draw_fps()
# Event loop
while True:
self._clear_items()
for event in pygame.event.get():
if event.type == QUIT:
self._quit()
if event.type == MOUSEBUTTONDOWN: # select a piece
log.debug('mouse pressed')
self._select_piece(event)
if event.type == MOUSEBUTTONUP: # let go of a piece
log.debug('mouse released')
self._drop_piece(event)
if pygame.event.get_grab(): # drag selected piece around
log.debug('dragging')
self._drag_piece()
self._draw_items()
self.fps_clock.tick(60) # Waits to maintain 60 fps
# TODO: Use display.update instead
pygame.display.flip()
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)
class Hud():
"""Class, which represents head-up display."""
def __init__(self, ai_settings, screen, stats, ship):
"""Initialize hud.
Args:
:param ai_settings: Instance of Settings class.
:param screen: Display Surface.
:param stats: Instance of GameStats class.
:param ship: Instance of Ship class.
"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
self.ship = ship
self.green_boss_hp = 19
self.red_boss_hp = 14
self.blue_boss_hp = 19
# Preparing of hud.
self.prep_health()
self.prep_ammo()
self.prep_shield()
self.prep_green_boss_health()
def prep_health(self):
"""Prepare to drawn ship health."""
self.health = Group()
for ship_number in range(self.stats.ships_left):
ship_health = ShipHealth(self.ai_settings, self.screen)
ship_health.rect.x = 20 + ship_number * (ship_health.rect.width +
10)
ship_health.rect.y = 28
self.health.add(ship_health)
def prep_green_boss_health(self):
"""Prepare to drawn green boss health."""
self.boss_health = GroupSingle()
boss_health = GreenBossHealth(self.ai_settings, self.screen)
hp_image = boss_health.hp_images[self.green_boss_hp]
boss_health.image = hp_image.copy()
boss_health.rect.x = 500
boss_health.rect.y = 50
self.boss_health.add(boss_health)
def prep_red_boss_health(self):
"""Prepare to drawn red boss health."""
self.boss_health = GroupSingle()
boss_health = RedBossHealth(self.ai_settings, self.screen)
hp_image = boss_health.hp_images[self.red_boss_hp]
boss_health.image = hp_image.copy()
boss_health.rect.x = 500
boss_health.rect.y = 50
self.boss_health.add(boss_health)
def prep_blue_boss_health(self):
"""Prepare to drawn blue boss track."""
self.boss_health = GroupSingle()
boss_health = BlueBossHealth(self.ai_settings, self.screen)
hp_image = boss_health.hp_images[self.blue_boss_hp]
boss_health.image = hp_image.copy()
boss_health.rect.x = 500
boss_health.rect.y = 50
self.boss_health.add(boss_health)
def prep_ammo(self):
"""Prepare to drawn ship ammo."""
self.ammo = Group()
for ammo in range(self.stats.ammo):
ship_ammo = ShipAmmo(self.ai_settings, self.screen)
ship_ammo.rect.x = 20 + ammo * (ship_ammo.rect.width + 10)
ship_ammo.rect.y = 60
self.ammo.add(ship_ammo)
def prep_shield(self):
"""Prepare to drawn ship shield."""
self.shield = Group()
for shield in range(self.stats.shields_left):
stats_shield = ShipShield(self.ai_settings, self.screen, self.ship)
stats_shield.rect.x = 20
stats_shield.rect.y = 750
self.shield.add(stats_shield)
def show_hud(self):
"""Draw hud on screen."""
self.health.draw(self.screen)
self.ammo.draw(self.screen)
self.shield.draw(self.screen)
if self.stats.stage in self.ai_settings.boss_stages:
self.boss_health.draw(self.screen)
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 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 run(self):
log.debug('starting game')
log.debug('initializing screen')
self.screen = self._screen_init()
log.debug('getting font')
self.font = pygame.font.Font(None, 36)
log.debug('loading background')
self.background, self.background_rect= self._get_background()
log.debug('building initial game board')
self._board_setup(brown_spaces=self.brown_spaces)
log.debug('initializing game pieces')
for player, x, y in self.game.start_positions():
new_piece = PieceSprite(player)
self.game.add_piece(new_piece, (x, y))
new_piece.update_from_board()
self.pieces.add(new_piece)
log.debug('drawing initial content to screen')
self.screen.blit(self.background, ORIGIN)
pygame.display.flip()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.fps_clock = Clock()
self._draw_fps()
# Event loop
while True:
self._clear_items()
for event in pygame.event.get():
if event.type == QUIT:
self._quit()
if event.type == MOUSEBUTTONDOWN: # select a piece
log.debug('mouse pressed')
self._select_piece(event)
if event.type == MOUSEBUTTONUP: # let go of a piece
log.debug('mouse released')
self._drop_piece(event)
if pygame.event.get_grab(): # drag selected piece around
log.debug('dragging')
self._drag_piece()
self._draw_items()
self.fps_clock.tick(60) # Waits to maintain 60 fps
# TODO: Use display.update instead
pygame.display.flip()
class Game(StatusHandler):
def __init__(self, title='Checkers', log_drag=False, show_fps=False, ip='127.0.0.1', port=5000, spectate=False):
self.game_running = True
self.player = None
self.log_drag = log_drag
self.show_fps = show_fps
self.window_title = title
self.game = NetBoard(handler=self, ip=ip, port=port, spectate=spectate)
# Initialize Game Groups
self.board_spaces = set()
self.pieces = RenderUpdates()
self.piece_selected = GroupSingle()
self.bg_text = RenderUpdates()
self.fg_text = RenderUpdates()
self.current_piece_position = ORIGIN
self.screen = None
self.fps_clock = None
self.font = None
self.background = None
self.background_rect = None
self.fps_text = None
self.winner_text = None
self.turn_text = None
self.player_text = None
self.game_id_text = None
def handle_game_id(self, game_id):
self.game_id_text.text = "Game: %s" % game_id
def handle_list(self, game_list, list_type):
if list_type == SPECTATE and game_list:
game_id = game_list[0]
self.game.client.spectate(game_id)
self.player_text.text = 'You are a spectator'
elif not list_type and game_list:
game_id = game_list[0]
self.game.client.join(game_id)
elif not list_type and not game_list:
self.game.client.new_game()
def handle_board(self, board):
for piece in board:
new_piece = PieceSprite(piece.player)
new_piece.king = piece.king
self.game.add_piece(new_piece, piece.location)
new_piece.update_from_board()
self.pieces.add(new_piece)
def handle_turn(self, player):
self.game.turn = player
def handle_you_are(self, player):
self.player = player
def handle_moved(self, src, dst):
moved_pieces = [p for p in self.pieces if p.location == src]
Board.move(self.game, src, dst)
if moved_pieces:
moved_pieces[0].update_from_board()
Sounds.play('slap.ogg')
log.debug("board after drop:\n%s", str(self.game))
def handle_captured(self, loc):
captured_pieces = [p for p in self.pieces if p.location == loc]
if captured_pieces:
self.pieces.remove(captured_pieces[0])
def _board_space_setup(self):
""" initialize board state """
for col, row in self.game.usable_positions():
self.board_spaces.add(Square(row, col))
def _screen_init(self):
""" Initialise screen """
self.screen = pygame.display.set_mode(SCREEN_RES)
pygame.display.set_caption(self.window_title)
return self.screen
def _get_background(self):
result = pygame.Surface(self.screen.get_size())
(bg_img, bg_rect) = Images.load('marble-board.jpg')
result.blit(bg_img, bg_rect)
return result.convert(), bg_rect
def _clear_items(self):
self.fg_text.clear(self.screen, self.background)
self.piece_selected.clear(self.screen, self.background)
self.pieces.clear(self.screen, self.background)
self.bg_text.clear(self.screen, self.background)
def _quit(self):
log.debug('quitting')
self.game.client.quit()
self.game_running = False
def _select_piece(self, event):
# select the piece by seeing if the piece collides with cursor
self.piece_selected.add(piece for piece in self.pieces
if piece.rect.collidepoint(event.pos)
and piece.player == self.player
and piece.player == self.game.turn)
# Capture piece's original position (at center) to determine move on drop
if len(self.piece_selected) > 0:
# Assumed: starting a move
pygame.event.set_grab(True)
self.pieces.remove(self.piece_selected)
self.current_piece_position = (self.piece_selected.sprite.rect.centerx,
self.piece_selected.sprite.rect.centery)
log.debug('grabbing input, picked up piece at %s', self.current_piece_position)
Sounds.play('slide.ogg')
def _drag_piece(self):
# Until button is let go, move the piece with the mouse position
if self.log_drag:
log.debug('dragging')
rect = self.piece_selected.sprite.rect
rect.centerx, rect.centery = pygame.mouse.get_pos()
if self.log_drag:
log.debug('updated piece to %s', pygame.mouse.get_pos())
def _reset_selected_piece(self):
self.piece_selected.sprite.update_from_board()
Sounds.play('slap.ogg')
log.debug("board after drop:\n%s", str(self.game))
def _drop_piece(self, event):
if pygame.event.get_grab():
pygame.event.set_grab(False)
log.debug('releasing input')
# center the piece on the valid space; if it is not touching a space, return it to its original position
space_selected = [space for space in self.board_spaces if space.collidepoint(event.pos)]
if self.piece_selected and space_selected:
log.debug('dropped a piece')
piece, space = self.piece_selected.sprite, space_selected[0]
try:
self.game.move(piece.location, (space.col, space.row))
except InvalidMoveException as ce:
log.debug(ce)
self._reset_selected_piece()
else:
log.debug('dropped on unplayable game space')
self._reset_selected_piece()
# Add piece back to stationary set
self.pieces.add(self.piece_selected)
# clean up for the next selected piece
self.piece_selected.empty()
def _draw_items(self):
self.bg_text.draw(self.screen)
self.pieces.draw(self.screen)
self.piece_selected.draw(self.screen)
self.fg_text.draw(self.screen)
def _update(self):
self.game.update()
self.fps_text.text = "%4.1f fps" % self.fps_clock.get_fps()
if self.player:
self.player_text.text = "Your pieces are %s" % self.player
if self.game.turn not in players:
self.turn_text.text = "Waiting for player"
else:
if self.player == self.game.turn:
self.turn_text.text = "Your turn"
else:
self.turn_text.text = "%s's turn" % self.game.turn.title()
if self.game.winner():
self.turn_text.text = ''
self.winner_text.text = "%s wins!" % self.game.winner().title()
else:
self.winner_text.text = ''
if not self.piece_selected and self.player == self.game.turn:
highlight_player = self.game.turn
else:
highlight_player = None
self.pieces.update(highlight_player)
self.piece_selected.update(self.game.turn)
self.bg_text.update()
self.fg_text.update()
def run(self):
log.debug('pre-initializing sound')
mixer.pre_init(buffer=32)
log.debug('starting game')
pygame.init()
log.debug('initializing screen')
self.screen = self._screen_init()
log.debug('getting font')
self.font = pygame.font.Font(None, 36)
log.debug('loading background')
self.background, self.background_rect = self._get_background()
log.debug('setting up drop locations')
self._board_space_setup()
log.debug('building text')
bg_rect = self.background_rect
class FPSText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.right, self.rect.bottom = bg_rect.right, bg_rect.bottom
self.fps_text = FPSText('', self.font, WHITE)
if self.show_fps:
self.fg_text.add(self.fps_text)
class TurnText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.centery = bg_rect.centerx, bg_rect.centery
self.turn_text = TurnText('', self.font, WHITE)
self.bg_text.add(self.turn_text)
class WinnerText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.centery = bg_rect.centerx, bg_rect.centery
self.winner_text = WinnerText('', self.font, WHITE)
self.fg_text.add(self.winner_text)
class PlayerText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.bottom = bg_rect.centerx, bg_rect.bottom
self.player_text = PlayerText('', pygame.font.Font(None, 24), WHITE)
self.bg_text.add(self.player_text)
class GameIdText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.top = bg_rect.centerx, bg_rect.top + (0.25 * self.font.get_height())
self.game_id_text = GameIdText('', pygame.font.Font(None, 20), WHITE)
self.bg_text.add(self.game_id_text)
log.debug('drawing initial content to screen')
self.screen.blit(self.background, ORIGIN)
pygame.display.flip()
self.piece_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.fps_clock = Clock()
# Event loop
while self.game_running:
self._clear_items()
for event in pygame.event.get():
if event.type == QUIT:
self._quit()
if event.type == MOUSEBUTTONDOWN: # select a piece
log.debug('mouse pressed')
self._select_piece(event)
if event.type == MOUSEBUTTONUP: # let go of a piece
log.debug('mouse released')
self._drop_piece(event)
if pygame.event.get_grab(): # drag selected piece around
self._drag_piece()
self._update()
self._draw_items()
self.fps_clock.tick(60) # Waits to maintain 60 fps
# TODO: Use display.update instead
pygame.display.flip()
log.debug('finishing game loop')
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()
player = Player(
SpriteSheet("resources/img/player.png").images_at(util.gen_sprite_list(7, 7, 128, 192, 0), [255, 0, 255]), 64,
Vector2(128, pi_globals.screenSize[1] / 2.0))
player.animController.isEnabled = True
# projectile = Projectile(SpriteSheet("resources/img/paper_animation.png").image_at(util.gen_sprite_list(26, 10, 50, 50, 0), [255, 255, 255]), 25, player.position, Vector2(25, 25), 0.0)
def endThrowFrameEvent(targetPlayer):
targetPlayer.animController.playingAnimationIndex = 0
player.animController.getAnimation(1).setFrameEvent(5, endThrowFrameEvent)
playerGroup = GroupSingle(player)
projectileGroup = Group()
# Joystick initialization
# TODO Move joystick stuff to a input management file
pygame.joystick.init()
hasJoystick = False
joystick = None
if pygame.joystick.get_count() > 0:
joystick = pygame.joystick.Joystick(0)
joystick.init()
hasJoystick = joystick.get_numaxes() >= 2
print("Has Joystick: " + str(hasJoystick))
def run(self):
log.debug('starting game')
log.debug('initializing screen')
self.screen = self._screen_init()
log.debug('getting font')
self.font = pygame.font.Font(None, 36)
log.debug('loading background')
self.background, self.background_rect = self._get_background()
log.debug('building initial game board')
self._board_setup(brown_spaces=self.brown_spaces)
log.debug('initializing game pieces')
for player, x, y in self.game.start_positions():
new_piece = PieceSprite(player)
self.game.add_piece(new_piece, (x, y))
new_piece.update_from_board()
self.pieces.add(new_piece)
log.debug('drawing initial content to screen')
self.screen.blit(self.background, ORIGIN)
pygame.display.flip()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.fps_clock = Clock()
self._draw_fps()
# Event loop
while True:
self._clear_items()
for event in pygame.event.get():
if event.type == QUIT:
self._quit()
if event.type == MOUSEBUTTONDOWN: # select a piece
log.debug('mouse pressed')
self._select_piece(event)
if event.type == MOUSEBUTTONUP: # let go of a piece
log.debug('mouse released')
self._drop_piece(event)
if pygame.event.get_grab(): # drag selected piece around
log.debug('dragging')
self._drag_piece()
self._draw_items()
self.fps_clock.tick(60) # Waits to maintain 60 fps
# TODO: Use display.update instead
pygame.display.flip()
class Game:
def __init__(self):
self._settings = GameSettings()
self.score_count = 0
self.can_pipe_move = True
self.is_game_over = False
pygame.init()
self.clock = pygame.time.Clock()
self.game_display = display.set_mode(
(self._settings.window_width, self._settings.window_height))
self.asset_factory = AssetFactory()
self._pipe_group = Group()
self._pipe_gaps = Group()
self._pipe_generator = PipeGenerator(self.asset_factory,
self._settings)
max_mum_pipes = int(
self._settings.window_width /
(self._settings.pipe_width + self._settings.pipe_distance))
self._max_num_pipe_parts = max_mum_pipes * PipeGenerator.NUM_PIPE_PARTS
self.__initialize_pipes__()
self.flappy_bird_img = self.asset_factory.create_flappy_bird_image(
BIRD_SIZE)
self.flappy_bird = FlappyBird(BIRD_START_POS, self.flappy_bird_img)
self.flappy_bird_group = GroupSingle(self.flappy_bird)
self.bg_img = self.asset_factory.create_bg(
self._settings.window_width, self._settings.window_height)
def __initialize_pipes__(self):
first_pipe_index = int(
self._settings.pipe_start_pos /
(self._settings.pipe_width + self._settings.pipe_distance))
for i in range(first_pipe_index, self._max_num_pipe_parts):
pipe_x = i * (self._settings.pipe_width +
self._settings.pipe_distance)
result = self._pipe_generator.create_pipe(pipe_x)
self._pipe_group.add([result.top_pipe, result.bottom_pipe])
self._pipe_gaps.add(result.pipe_gap)
def __update_pipes__(self):
# Create more pipes if there's space
# Each pipe actually has two parts, top and bottom
num_sprites_to_add = self._max_num_pipe_parts - \
len(self._pipe_group.sprites())
if num_sprites_to_add > 0:
for _ in range(0, num_sprites_to_add):
self.__create_pipe_from_end__()
def __create_pipe_from_end__(self):
last_pipe = self._pipe_group.sprites()[-1]
new_pipe_x = last_pipe.rect.x + \
self._settings.pipe_width + self._settings.pipe_distance
result = self._pipe_generator.create_pipe(new_pipe_x)
self._pipe_group.add([result.top_pipe, result.bottom_pipe])
self._pipe_gaps.add(result.pipe_gap)
def start(self):
while True:
# Clear display
for event in pygame.event.get():
if event.type == pygame.QUIT:
raise SystemExit
elif event.type == pygame.KEYDOWN and event.key == pygame.K_UP:
self.flappy_bird.do_flap()
if self.is_bird_dead():
self.handle_game_over()
elif self.has_bird_passed_pipe():
self.increase_score()
pygame.Surface.blit(self.game_display, self.bg_img, [0, 0])
self.update_sprites()
self.draw_sprites()
pygame.display.flip()
self.clock.tick(60)
def handle_game_over(self):
if not self.is_game_over:
self.is_game_over = True
self.flappy_bird.fall_to_y_pos(self._settings.window_height)
self.can_pipe_move = False
print("Game over. Final score was: " + str(self.score_count))
def increase_score(self):
if self.is_game_over:
return
self.score_count = self.score_count + 1
print("Score is: " + str(self.score_count))
def is_bird_dead(self):
# Game ends when bird collides with pipe
collided_sprite = sprite.spritecollideany(self.flappy_bird,
self._pipe_group)
if collided_sprite is not None:
return True
# Bird stops moving when hitting near bottom of screen
bird_death_pos_y = self._settings.window_height - 20
if self.flappy_bird.rect.bottom >= bird_death_pos_y:
return True
return False
def has_bird_passed_pipe(self):
# Score increments when bird goes through pipe gap
collided_gaps = sprite.spritecollide(self.flappy_bird, self._pipe_gaps,
False)
for collided_gap in collided_gaps:
if collided_gap.is_collided_for_first_time():
self.increase_score()
def update_sprites(self):
self.flappy_bird_group.update()
self.__update_pipes__()
if self.can_pipe_move:
self._pipe_group.update(MAP_MOVE_SPEED)
self._pipe_gaps.update(MAP_MOVE_SPEED)
def draw_sprites(self):
self.flappy_bird_group.draw(self.game_display)
self._pipe_group.draw(self.game_display)
self._pipe_gaps.draw(self.game_display)
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)
class Game(Application):
def __init__(self):
Application.__init__(self)
self.screenRect = self.screen.get_rect()
self.minDt = 200
self.enemyGroup = Group()
self.enemyGroup.add(BasicEnemy(100,100,0,1,self.screenRect,80))
self.bulletGroup = Group()
self.player = Player(self.screenRect)
self.playerGroup = GroupSingle(self.player)
self.playerWeaponType = 1
self.playerFired = False
self.playerMoveX = 0
self.playerMoveY = 0
self.playerMoveFlag = False
def handle_event(self,event):
if event.type == MOUSEBUTTONUP and event.button == 1:
self.playerFired = True
if event.type == KEYDOWN:
## need to put in KEYUP to turn off the thing...
if event.key == K_DOWN:
self.playerMoveY = 1
self.playerMoveFlag = True
if event.key == K_UP:
self.playerMoveY = -1
self.playerMoveFlag = True
if event.key == K_LEFT:
self.playerMoveX = -1
self.playerMoveFlag = True
if event.key == K_RIGHT:
self.playerMoveX = 1
self.playerMoveFlag = True
if event.key == K_SPACE:
self.playerFired = True
if event.type == KEYUP:
if event.key == K_DOWN:
self.playerMoveY = 0
self.playerMoveFlag = True
if event.key == K_UP:
self.playerMoveY = 0
self.playerMoveFlag = True
if event.key == K_LEFT:
self.playerMoveX = 0
self.playerMoveFlag = True
if event.key == K_RIGHT:
self.playerMoveX = 0
self.playerMoveFlag = True
def update(self, screen):
dt = min(self.minDt, self.clock.get_time())
self.enemyGroup.update(dt)
if self.playerFired:
self.bulletGroup.add(self.player.shoot(self.playerWeaponType))
self.playerFired = False
## need to validate holding down the key...
if self.playerMoveFlag:
self.player.setDirection(self.playerMoveX, self.playerMoveY)
self.playerMoveFlag = False
self.bulletGroup.update(dt)
self.playerGroup.update(dt)
pygame.sprite.groupcollide(self.enemyGroup, self.bulletGroup, True, True)
def draw(self,screen):
screen.fill((0,0,0))
self.playerGroup.draw(screen)
self.enemyGroup.draw(screen)
self.bulletGroup.draw(screen)
self.image = load('imagens/Cometa_ofc.png')
self.rect = self.image.get_rect(center=(800, randint(20, 580)))
def update(self):
global perdeu
self.rect.x -= 0.1
if self.rect.x == 0:
self.kill()
grupo_cometas = Group()
grupo_balas = Group()
foguete = Foguete(grupo_balas)
grupo_foguete = GroupSingle(foguete)
grupo_cometas.add(Cometa())
clock = Clock()
abates = 0
round = 0
perdeu = False
vida_foguete = 3
pygame.mixer.music.load("sons/musica_fundo.ogg")
pygame.mixer.music.set_volume(0.1)
pygame.mixer.music.play(-1)
while True:
clock.tick(120)
def run_game():
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.mixer.init()
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
ship = Ship(ai_settings, screen)
stats = GameStats(ai_settings)
hud = Hud(ai_settings, screen, stats, ship)
play_button = Button(screen, "Start")
bullets = Group()
aliens = Group()
alien_bullets = Group()
health = Group()
ammo = Group()
used_shields = Group()
bosses = GroupSingle()
boss_shields = GroupSingle()
clock = pygame.time.Clock()
boss_bullets = Group()
black_holes = GroupSingle()
ai_settings.state = ai_settings.running
# Main game cycle.
while True:
dt = clock.tick()
gf.check_events(ai_settings, screen, stats, hud, play_button, ship,
aliens, bullets, used_shields)
gf.check_keys_pressed(ship)
if ai_settings.state == ai_settings.running:
if stats.game_active:
ship.update()
gf.update_ship_shield(ship, alien_bullets, used_shields,
boss_bullets)
gf.update_bullets(ai_settings, screen, stats, hud, ship,
aliens, bullets, alien_bullets, health, ammo,
bosses, boss_bullets, boss_shields,
black_holes)
gf.update_aliens(ai_settings, screen, stats, hud, ship, aliens,
bullets, alien_bullets, health, ammo,
used_shields)
gf.fire_alien_bullets(ai_settings, screen, stats, ship, aliens,
alien_bullets, dt)
gf.update_alien_bullets(ai_settings, screen, stats, hud, ship,
aliens, bullets, alien_bullets, health,
ammo, used_shields)
if stats.stage == ai_settings.boss_stages[0]:
gf.update_green_boss(ai_settings, screen, stats, hud, ship,
bullets, used_shields, bosses,
boss_bullets, boss_shields, bosses)
gf.fire_green_boss_bullets(ai_settings, screen, dt, bosses,
boss_bullets)
gf.update_green_boss_bullets(ai_settings, screen, stats,
hud, ship, bullets,
used_shields, bosses,
boss_bullets, boss_shields,
black_holes)
gf.update_green_boss_shield(hud, bullets, boss_shields)
elif stats.stage == ai_settings.boss_stages[1]:
gf.update_red_boss(ai_settings, screen, stats, hud, ship,
bullets, used_shields, bosses,
boss_bullets, boss_shields, black_holes)
gf.update_red_boss_shield(hud, bullets, boss_shields)
gf.fire_red_boss_bullets(ai_settings, screen, ship, dt,
bosses, boss_bullets)
gf.update_red_boss_bullets(ai_settings, screen, stats, hud,
ship, bullets, used_shields,
bosses, boss_bullets,
boss_shields, black_holes)
elif stats.stage == ai_settings.boss_stages[2]:
gf.update_blue_boss(ai_settings, screen, stats, hud, ship,
bullets, used_shields, bosses,
boss_bullets, boss_shields,
black_holes)
gf.update_blue_boss_shield(hud, bullets, boss_shields)
gf.fire_blue_boss_bullets(ai_settings, screen, dt, bosses,
boss_bullets)
gf.update_blue_boss_bullets(ai_settings, screen, stats,
hud, ship, bullets,
used_shields, bosses,
boss_bullets, boss_shields,
black_holes)
gf.create_black_hole(ai_settings, screen, ship, dt,
black_holes)
gf.update_black_hole(ai_settings, screen, stats, hud, ship,
bullets, used_shields, dt, bosses,
boss_bullets, boss_shields,
black_holes)
gf.update_ship_health(stats, hud, ship, health)
gf.update_ship_ammo(stats, hud, ship, ammo)
elif ai_settings.state == ai_settings.paused:
pass
if ai_settings.state == ai_settings.running:
gf.update_screen(ai_settings, screen, stats, hud, ship, aliens,
bullets, alien_bullets, play_button, health, ammo,
used_shields, dt, bosses, boss_bullets,
boss_shields, black_holes)
else:
pass
class Game(object):
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
font = pygame.font.Font(None,35)
def __init__ (self):
self.SCREEN_SIZE = SCREEN_SIZE
self.BG_COLOR = BG_COLOR
self.score = 0
self.spawntime = 10
self.spawnticker = 0
self.robot_grp = Group()
#initialize pygame
#initialize game
self.player = Player(self.bounds.center, self.bounds) #sets starting position fir player
robot = Robot((randrange(0,800),randrange(0,600)), self.bounds)
self.player_grp = GroupSingle(self.player)
#robot_grp = GroupSingle(robot)
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.meteors = Group()
self.impacts = Group()
self.play()
#game loop
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 quit(self):
self.done = True
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()
#draw
def draw(self):
screen = self.screen
self.screen.fill(BG_COLOR)
self.robot_grp.draw(screen)
ImpactGroup.impacts.draw(screen)
self.meteors.draw(screen)
self.player_grp.draw(screen)
self.robot_grp.draw(screen)
self.clock.tick(30)
score_text = self.font.render("Score: %05d"%self.score, False, (255,255,255))
screen.blit(score_text, (5,5))
pygame.display.flip()
def run(self):
log.debug('pre-initializing sound')
mixer.pre_init(buffer=32)
log.debug('starting game')
pygame.init()
log.debug('initializing screen')
self.screen = self._screen_init()
log.debug('getting font')
self.font = pygame.font.Font(None, 36)
log.debug('loading background')
self.background, self.background_rect = self._get_background()
log.debug('setting up drop locations')
self._board_space_setup()
log.debug('building text')
bg_rect = self.background_rect
class FPSText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.right, self.rect.bottom = bg_rect.right, bg_rect.bottom
self.fps_text = FPSText('', self.font, WHITE)
if self.show_fps:
self.fg_text.add(self.fps_text)
class TurnText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.centery = bg_rect.centerx, bg_rect.centery
self.turn_text = TurnText('', self.font, WHITE)
self.bg_text.add(self.turn_text)
class WinnerText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.centery = bg_rect.centerx, bg_rect.centery
self.winner_text = WinnerText('', self.font, WHITE)
self.fg_text.add(self.winner_text)
class PlayerText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.bottom = bg_rect.centerx, bg_rect.bottom
self.player_text = PlayerText('', pygame.font.Font(None, 24), WHITE)
self.bg_text.add(self.player_text)
class GameIdText(Text):
def update(self, *args):
Text.update(self, *args)
self.rect.centerx, self.rect.top = bg_rect.centerx, bg_rect.top + (0.25 * self.font.get_height())
self.game_id_text = GameIdText('', pygame.font.Font(None, 20), WHITE)
self.bg_text.add(self.game_id_text)
log.debug('drawing initial content to screen')
self.screen.blit(self.background, ORIGIN)
pygame.display.flip()
self.piece_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.fps_clock = Clock()
# Event loop
while self.game_running:
self._clear_items()
for event in pygame.event.get():
if event.type == QUIT:
self._quit()
if event.type == MOUSEBUTTONDOWN: # select a piece
log.debug('mouse pressed')
self._select_piece(event)
if event.type == MOUSEBUTTONUP: # let go of a piece
log.debug('mouse released')
self._drop_piece(event)
if pygame.event.get_grab(): # drag selected piece around
self._drag_piece()
self._update()
self._draw_items()
self.fps_clock.tick(60) # Waits to maintain 60 fps
# TODO: Use display.update instead
pygame.display.flip()
log.debug('finishing game loop')
from core import config
from core import color
from game import gamedata
### Constants ##################################################################
ALARM_LINE = 2
BLOCK_TYPE = None
CELL_SIZE = (32, 32)
COMBOS = tuple(config.load_sound('combo%d.wav' % i) for i in range(1, 6))
SIZE = (20, 12) #(width, height)
RECT = Rect(0, 0, get_surface().get_width(), SIZE[1] * CELL_SIZE[1])
################################################################################
### Globals ####################################################################
blocks = None
block_buffer = GroupSingle(Sprite())
_blocks_to_check = set()
_blocks_to_clear = set()
_block_clear = config.load_sound('clear.wav')
block_buffer.sprite.rect = Rect(0, 0, 0, 0)
################################################################################
def any_active():
s = BLOCK_TYPE.STATES
for i in BLOCK_TYPE.GROUP:
if i.state not in {s.IDLE, s.ACTIVE}:
#If this block is moving...
return True
self.image = load('images/inimigo_1.png')
self.rect = self.image.get_rect(center=(800, randint(20, 580)))
def update(self):
global perdeu
self.rect.x -= 0.1
if self.rect.x == 0:
self.kill()
perdeu = True
grupo_inimigos = Group()
grupo_torradas = Group()
dunofausto = Dunofausto(grupo_torradas)
grupo_duno = GroupSingle(dunofausto)
grupo_inimigos.add(Virus())
clock = Clock()
mortes = 0
round = 0
perdeu = False
while True:
# Loop de eventos
clock.tick(120) # FPS
if round % 120 == 0:
if mortes < 20:
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)
class Game:
def __init__(self, title='Checkers', log_level=log.INFO, show_fps=False):
log.basicConfig(level=log_level)
self.show_fps = show_fps
self.window_title = title
self.game = Board(BOARD_DIM)
# Initialize Game Groups
self.brown_spaces = RenderUpdates()
self.pieces = RenderUpdates()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.screen = None
self.fps_clock = None
self.font = None
self.font_rect = None
self.background = None
self.background_rect = None
self.fps_text = None
self.fps_rect = None
self.winner_text = None
self.winner_rect = None
def _board_setup(self, **kwargs):
""" initialize board state """
brown_spaces = kwargs.get('brown_spaces')
for col, row in self.game.usable_positions():
loc = TILE_WIDTH * col + (BORDER_WIDTH /
2), TILE_WIDTH * row + (BORDER_WIDTH / 2)
brown_spaces.add(SquareSprite(loc, "brown", row, col))
def _screen_init(self):
""" Initialise screen """
pygame.init()
self.screen = pygame.display.set_mode(SCREEN_RES)
pygame.display.set_caption(self.window_title)
return self.screen
def _get_background(self):
result = pygame.Surface(self.screen.get_size())
(bg_img, bg_rect) = ImageLoader.load_img('marble-board.jpg')
result.blit(bg_img, bg_rect)
return result.convert(), bg_rect
def _get_fps_text(self):
fps_text = self.font.render("%4.1f fps" % self.fps_clock.get_fps(),
True, WHITE)
rect = fps_text.get_rect()
rect.right, rect.bottom = self.background_rect.right, self.background_rect.bottom
return fps_text, rect
def _draw_fps(self):
if self.show_fps:
self.fps_text, self.fps_rect = self._get_fps_text()
self.screen.blit(self.fps_text, self.fps_rect)
def _clear_fps(self):
if self.show_fps:
self.screen.blit(self.background,
self.fps_rect,
area=self.fps_rect)
def _clear_items(self):
self._clear_winner()
self._clear_fps()
self.piece_selected.clear(self.screen, self.background)
self.pieces.clear(self.screen, self.background)
def _draw_winner(self):
winner = self.game.winner()
if winner:
self.winner_text = self.font.render("%s wins!" % winner.title(),
True, WHITE)
winner_rect = self.winner_text.get_rect()
winner_rect.centerx = self.background.get_rect().centerx
winner_rect.top = 100
self.winner_rect = winner_rect
self.screen.blit(self.winner_text, winner_rect)
def _clear_winner(self):
winner = self.game.winner()
if winner:
self.screen.blit(self.background,
self.winner_rect,
area=self.winner_rect)
def _quit(self):
log.debug('quitting')
sys.exit()
def _select_piece(self, event):
# select the piece by seeing if the piece collides with cursor
self.piece_selected.add(piece for piece in self.pieces
if piece.rect.collidepoint(event.pos))
# Capture piece's original position (at center) to determine move on drop
if len(self.piece_selected) > 0:
# Assumed: starting a move
pygame.event.set_grab(True)
self.pieces.remove(self.piece_selected)
self.current_piece_position = (
self.piece_selected.sprite.rect.centerx,
self.piece_selected.sprite.rect.centery)
log.debug('grabbing input, picked up piece at %s',
self.current_piece_position)
def _drag_piece(self):
# Until button is let go, move the piece with the mouse position
self.piece_selected.update(pygame.mouse.get_pos())
log.debug('updated piece to %s', pygame.mouse.get_pos())
def _drop_piece(self, event):
if pygame.event.get_grab():
pygame.event.set_grab(False)
log.debug('releasing input')
# center the piece on the valid space; if it is not touching a space, return it to its original position
self.space_selected.add(space for space in self.brown_spaces
if space.rect.collidepoint(event.pos))
if self.piece_selected and self.space_selected:
log.debug('dropped a piece')
piece, space = self.piece_selected.sprite, self.space_selected.sprite
try:
captured = self.game.move(piece.location,
(space.col, space.row))
if captured:
self.pieces.remove(captured)
except InvalidMoveException as ce:
log.debug(ce)
log.debug("%s", str(self.game))
self.piece_selected.sprite.update_from_board()
# Add piece back to stationary set
self.pieces.add(self.piece_selected)
# clean up for the next selected piece
self.piece_selected.empty()
self.space_selected.empty()
def _draw_items(self):
self.pieces.draw(self.screen)
self.piece_selected.draw(self.screen)
self._draw_winner()
self._draw_fps()
def run(self):
log.debug('starting game')
log.debug('initializing screen')
self.screen = self._screen_init()
log.debug('getting font')
self.font = pygame.font.Font(None, 36)
log.debug('loading background')
self.background, self.background_rect = self._get_background()
log.debug('building initial game board')
self._board_setup(brown_spaces=self.brown_spaces)
log.debug('initializing game pieces')
for player, x, y in self.game.start_positions():
new_piece = PieceSprite(player)
self.game.add_piece(new_piece, (x, y))
new_piece.update_from_board()
self.pieces.add(new_piece)
log.debug('drawing initial content to screen')
self.screen.blit(self.background, ORIGIN)
pygame.display.flip()
self.piece_selected = GroupSingle()
self.space_selected = GroupSingle()
self.current_piece_position = ORIGIN
self.fps_clock = Clock()
self._draw_fps()
# Event loop
while True:
self._clear_items()
for event in pygame.event.get():
if event.type == QUIT:
self._quit()
if event.type == MOUSEBUTTONDOWN: # select a piece
log.debug('mouse pressed')
self._select_piece(event)
if event.type == MOUSEBUTTONUP: # let go of a piece
log.debug('mouse released')
self._drop_piece(event)
if pygame.event.get_grab(): # drag selected piece around
log.debug('dragging')
self._drag_piece()
self._draw_items()
self.fps_clock.tick(60) # Waits to maintain 60 fps
# TODO: Use display.update instead
pygame.display.flip()
player = Player(
SpriteSheet("resources/img/player.png").images_at(
util.gen_sprite_list(7, 7, 128, 192, 0), [255, 0, 255]), 64,
Vector2(128, pi_globals.screenSize[1] / 2.0))
player.animController.isEnabled = True
# projectile = Projectile(SpriteSheet("resources/img/paper_animation.png").image_at(util.gen_sprite_list(26, 10, 50, 50, 0), [255, 255, 255]), 25, player.position, Vector2(25, 25), 0.0)
def endThrowFrameEvent(targetPlayer):
targetPlayer.animController.playingAnimationIndex = 0
player.animController.getAnimation(1).setFrameEvent(5, endThrowFrameEvent)
playerGroup = GroupSingle(player)
projectileGroup = Group()
# Joystick initialization
# TODO Move joystick stuff to a input management file
pygame.joystick.init()
hasJoystick = False
joystick = None
if pygame.joystick.get_count() > 0:
joystick = pygame.joystick.Joystick(0)
joystick.init()
hasJoystick = joystick.get_numaxes() >= 2
print("Has Joystick: " + str(hasJoystick))
