def run_game():
#Initializer game, settings and create a screen object
pygame.init()
screen_width = 1200
screen_height = 1200
bg_color = (168, 164, 0)
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Raindrops")
raindrops = Group()
draw_raindrops(screen, raindrops, screen_width, screen_height)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
#Redraw the screen during each pass through the for loop
screen.fill(bg_color)
for raindrop in raindrops:
if randint(0,1) == 1:
raindrop.rect.y += 1
if raindrop.rect.bottom > screen_height:
raindrops.remove(raindrop)
raindrop.blitme()
#Make the most recently drawn screen visible
pygame.display.flip()
def run_game():
#initial game and make a screen target
pygame.init()
setting = Setting()
screen = pygame.display.set_mode((setting.screen_width, setting.screen_height))
ship = Ship(setting, screen)
bullets = Group()
aliens = Group()
gf.creat_fleet(setting, screen, aliens)
pygame.display.set_caption(setting.caption)
#begin main loop
while True:
#watch keyboard and mouse
gf.check_events(ship, bullets, setting, screen)
ship.update_position()
bullets.update()
aliens.update()
#delete bullet outside of the screen
for bullet in bullets.copy():
if bullet.rect.bottom < 0:
bullets.remove(bullet)
#move aliens
gf.get_fleet_direction(aliens, setting)
#kill aliens
gf.kill(aliens, bullets)
#refresh screen
gf.update_screen(screen, setting, ship, bullets, aliens)
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# make a ship
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
alien = Alien(ai_settings, screen)
gf.create_fleet(ai_settings, screen, aliens)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
bullets.update()
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(ai_settings, screen, "Play")
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
alien = Alien(ai_settings, screen)
gf.create_fleet(ai_settings, screen, ship, aliens)
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,
bullets, play_button)
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
def run_game():
# Initl game and create a screen object
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# create ship
ship = Ship(ai_settings, screen)
#create bullet
bullets = Group()
# Start game
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# delect bullet
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(ai_settings, screen, ship, bullets)
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((
(ai_settings.screen_width, ai_settings.screen_height)
))
pygame.display.set_caption("Corona Python")
play_button = Button(ai_settings, screen, "Play")
doctor = Doctor(ai_settings, screen)
bullets = Group()
viruses = Group()
stats = GameStats(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats)
gf.create_fleet(ai_settings, screen, doctor, viruses)
while True:
gf.check_events(ai_settings, screen, stats,
sb, play_button, doctor, viruses, bullets)
if stats.game_active:
doctor.update()
gf.update_bullets(ai_settings, screen, stats,
sb, doctor, viruses, bullets)
gf.update_bullets(ai_settings, screen, stats,
sb, doctor, viruses, bullets)
gf.update_viruses(ai_settings, stats, screen,
doctor, viruses, bullets)
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
gf.update_screen(ai_settings, screen, stats, sb, doctor,
viruses, bullets, play_button)
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# make a ship
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
alien = Alien(ai_settings, screen)
gf.create_fleet(ai_settings, screen, aliens)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
bullets.update()
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Pick the stars")
people = People(ai_settings, screen)
stars = Stars(ai_settings, screen)
alien = Alien(ai_settings, screen)
bullets = Group()
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
play_button = Button(ai_settings, screen, "Play")
while True:
gf.check_events(ai_settings, stats, sb, people, alien, bullets,
play_button)
bullets.update()
for bullet in bullets.copy():
if bullet.rect.bottom >= ai_settings.screen_height:
bullets.remove(bullet)
if stats.game_active:
people.update()
gf.update_alien(alien)
gf.update_stars(ai_settings, stats, sb, people, stars)
if alien.rect.x % 120 == 0:
gf.update_bullet(ai_settings, stats, screen, people, alien,
bullets)
gf.update_screen(ai_settings, stats, sb, screen, people, stars, alien,
bullets, play_button)
def run_stars():
setting = Settings()
#make screen
display = make_display(setting)
rect = display.get_rect()
#star class
star = Star(display, setting)
stars = Group()
#making the grid of stars appear
total_usable = get_columbs(display, setting)
total_star_room = get_rows(display, setting, stars, total_usable)
star_grid_code(total_usable, total_star_room, display, stars, setting)
counter = 0
while counter < 10000:
check_events()
star.draw_stars(stars, display)
update_stars(stars, display, setting)
#should remove the stars from the group of stars
for star in stars.copy():
if star.rect.top == rect.bottom:
stars.remove(star)
new_row_stars(display, setting, total_star_room, stars)
pygame.display.flip()
counter += 1
def run_game():
#初始化游戏
pygame.init()
#实例化设置对象
ai_settings = Settings()
#创建屏幕
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
#设置游戏标题
pygame.display.set_caption(ai_settings.caption)
#创建飞船
ship = Ship(screen, ai_settings)
#创建子弹列表
bullets = Group()
#开始游戏的主循环
while True:
screen.fill(ai_settings.bg_color)
#监视键盘和鼠标事件
gf.check_events(ai_settings, screen, ship, bullets)
#更新飞船位置
ship.update()
#更新子弹位置
bullets.update()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
#更新屏幕
gf.update_screen(ai_settings, screen, ship, bullets)
def run_game():
#初始化一个屏幕
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)
# 创建一个用于存储子弹的编组
bullets = Group()
#开始游戏的主循环
while True:
#监视鼠标键盘事件
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# 删除已消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
gf.update_screen(ai_settings, screen, ship, bullets)
def run_game():
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(screen)
bullets = Group()
# alien = Alien(ai_settings, screen)
aliens = Group()
gf.create_fleet(ai_settings, screen, aliens)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
gf.update_aliens(ai_settings, aliens)
pygame.sprite.groupcollide(bullets, aliens, True, True)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
pygame.display.flip()
def run_game():
# Initialize pygame, settings and screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Set the background color.
bg_color = (230, 230, 230)
# Make a ship, a group of bullets, and a group of aliens.
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
# Create a fleet of aliens.
gf.create_fleet(ai_settings, screen, ship, aliens)
# Start the Main loop for the game,
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_aliens(ai_settings, aliens)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def run_game():
# 初始化pygame、设置和屏幕对象
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_hegiht))
pygame.display.set_caption("Alien Invasion")
#创建一艘飞船
ship = Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
#设置背景颜色
bg_color = (ai_settings.bg_color)
#开始游戏的主循环
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# 删除已消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(ai_settings, screen, ship, bullets)
def run_game():
pygame.init()
# 设置size
screen = pygame.display.set_mode((1200, 800))
# 设置title
pygame.display.set_caption('Alien')
# init ship
ship = Ship(screen)
# init monster
monster = Group()
bullets = Group()
# 随机怪物的数量
monsters_num = random.uniform(0, 10)
gf.create_alien(screen, monster, monsters_num)
while True:
# 检测键盘事件
gf.check_events(ship, screen, bullets)
# 改变自己位置
ship.update()
bullets.update()
monster.update()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
print("删除消失的子弹")
bullets.remove(bullet)
# 判断怪物是不是被杀死了
gf.check_bullet_alien_collisions(screen, monster, bullets)
# 如果自己移动，重绘屏幕
gf.update_screen(screen, ship, bullets, monster)
def run_game():
# 初始化 pygame 、设置和屏幕对象
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)
# 创建一个用于存储子弹的编组
bullets = Group()
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 开始游戏主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# 删除已消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
gf.update_bullets(aliens, bullets)
gf.update_aliens(ai_settings, aliens)
# 每次循环时都重绘屏幕
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
# 让最近绘制的屏幕可见
pygame.display.flip()
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width,
ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
bg_color = (230,230,230)
ship = Ship(ai_settings,screen)
bullets = Group()
while True:
gf.check_events(ai_settings, screen, ship, bullets)
# 每次循环，都调用ship的update
ship.update()
bullets.update()##这个子弹的跟新，子弹往前飞
##删除已经消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom<=0:
bullets.remove(bullet)
# print(len(bullets)) #用于确认子弹确实消失了
gf.update_screen(ai_settings, screen, ship, bullets)
def run_game(): #Initialize game pygame.init() ai_settings = Settings() screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height)) # Make a ship. ship = Ship(screen) stats = GameStats(ai_settings) bullets = Group() aliens = Group() gf.create_fleet(ai_settings, screen, ship, aliens) #Main loop for the game: while True: gf.check_events(ai_settings, ship, bullets) gf.update_screen(ai_settings, screen, ship, aliens, bullets) gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets) for bullet in bullets.copy(): if bullet.rect.bottom <= 0: bullets.remove(bullet)
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Make a ship.
ship = Ship(ai_settings, screen)
# Make a group to store bullets in.
bullets = Group()
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(ai_settings, screen, ship, bullets)
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Make a ship
ship = Ship(ai_settings, screen)
# Make a group to store bullets in.
bullets = Group()
# Set the background color.
bg_color = (50, 20, 10)
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(bullets)
gf.update_screen(ai_settings, screen, ship, bullets)
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
# Watch for keyboard and mouse events.
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
# Redraw the screen during each pass through the loop.
screen.fill(ai_settings.bg_color)
ship.blitme()
# Make the most recently drawn screen visible.
pygame.display.flip()
def run_game():
pygame.init() #初始化背景设置
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
#创建一个名为screen的显示窗口,实参（1200,800）实际上是一个元祖，制定了游戏窗口的尺寸，此处宽1200，高800像素
pygame.display.set_caption("AlienGame Invasion") ##设置窗口标题
#创建一个外星人
alien = Alien(ai_settings, screen)
#创建一艘飞船、一个子弹编组和一个外星人编组
ship = Ship(ai_settings, screen)
aliens = Group()
bullets = Group()
#创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
#开始游戏主循环
while True:
gf.check_events(ai_settings, screen, ship, aliens, bullets)
ship.update()
bullets.update()
#删除已消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
gf.update_bullets(aliens, bullets)
gf.update_aliens(ai_settings, aliens)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def run_game():
#初始化游戏并创建一个屏幕,创建setting实例和船实例,给游戏命名
pygame.init()
ai_setting=Settings()
screen=pygame.display.set_mode(
(ai_setting.screen_width,ai_setting.screen_height))
pygame.display.set_caption('Alien Invasion')
ship=Ship(ai_setting,screen)
#创建用于存储子弹的编组
bullets=Group()
aliens=Group()
#开始游戏主循环
while True:
#监视键盘和鼠标事件
gf.check_events(ai_setting,screen,ship,bullets)
ship.update()
gf.create_fleet(screen,ai_setting,ship,aliens)
bullets.update()
for bullet in bullets.copy():
if bullet.rect.right>1200:
bullets.remove(bullet)
gf.update_screen(ai_setting,screen,ship,bullets,aliens)
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init()
#创建Settings实例存储在ai_settings变量中
ai_settings = Settings()
#使用ai_settings的属性screen_width和screen_height
screen = pygame.display.set_mode(
(ai_settings.screen_width,ai_settings.screen_height)
)
pygame.display.set_caption("Alien Invasion")
#创建一艘飞船
#需要传入实参ai_settings
ship = Ship(ai_settings,screen)
#创建一个用于存储子弹的编组
#pygame.sprite.Group类创建一个编组，存储所有有效子弹，类似列表。
bullets = Group()
#开始游戏的循环
while True:
gf.check_events(ai_settings,screen,ship,bullets)
#飞船的位置在检测到键盘事件后(但在更新屏幕前)更新。
ship.update()
#当对编组调用update()时，编组将自动对其中每个精灵(子弹)调用update()
bullets.update()
#删除已消失的子弹
#不应从列表或编组中删除条目，因此必须遍历编组的副本
#我们使用了方法copy()来设置for循环
for bullet in bullets.copy():
#检查每颗子弹，看看它是否已从屏幕消失。
if bullet.rect.bottom <= 0:
#从bullets中删除
bullets.remove(bullet)
#显示还有多少子弹
print(len(bullets))
gf.update_screen(ai_settings,screen,ship,bullets)
class UFOs:
def __init__(self, game):
self.settings = game.settings
self.screen = game.screen
self.game = game
self.ufo_group = Group()
self.last_ufo = pg.time.get_ticks()
def create_ufo_if_time(self):
now = pg.time.get_ticks()
if now > self.last_ufo + self.settings.ufo_every * 1000:
self.ufo_group.add(UFO(game=self.game, parent=self))
self.last_ufo = pg.time.get_ticks()
def update(self):
self.create_ufo_if_time()
self.ufo_group.update()
for ufo in self.ufo_group.sprites():
ufo.draw()
if ufo.check_edges():
self.ufo_group.remove(ufo)
bullet_ufo_collision = pg.sprite.groupcollide(
self.ufo_group, self.game.ship.bullet_group_that_kill_aliens, True,
True)
if bullet_ufo_collision:
for ufo in bullet_ufo_collision:
print('UFO HIT')
ufo.killed()
def draw(self):
for ufo in self.ufo_group:
ufo.draw()
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 创建Play按钮
play_button = Button(ai_settings, screen, "Play")
# 创建一个用于存储游戏统计信息的实例，并创建记分牌
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
alien = Alien(ai_settings, screen)
gf.create_fleet(ai_settings, screen, ship, aliens)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update(ai_settings)
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets)
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
class SpriteGroup:
ALL_SPRITES = Group()
def __init__(self):
self.sprites = Group()
@property
def children(self):
return self.sprites
def add(self, sprite: Sprite):
self.ALL_SPRITES.add(sprite)
self.sprites.add(sprite)
def remove(self, sprite: Sprite):
self.ALL_SPRITES.remove(sprite)
self.sprites.remove(sprite)
def update(self):
self.sprites.update()
def draw(self, screen):
for sprite in self.sprites:
if hasattr(sprite, 'on_draw'):
sprite.on_draw(screen)
sprite.draw(screen)
def empty(self):
return self.sprites.empty()
def __iter__(self):
return self.sprites.__iter__()
def __len__(self):
return len(self.sprites)
def run_game():
pygame.init()
ai_settings = Settings()
""" Screen settings and such"""
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
stats = GameStats(ai_settings)
bg_color = (230, 230, 230)
"""background screen color; grey"""
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
def run_game():
#initialize game and create a screen object.
pygame.init()
gamesettings = Settings()
screen = pygame.display.set_mode(
(gamesettings.screen_width, gamesettings.screen_height))
pygame.display.set_caption("Alien Invasion")
#make a ship
ship = Ship(gamesettings, screen)
#make a group to store bullets
bullets = Group()
aliens = Group()
#make an alien
alien = Alien(gamesettings, screen)
#create the fleet of aliens
gf.create_fleet(gamesettings, screen, ship, aliens)
#start main loop for game
while True:
gf.check_events(gamesettings, screen, ship, bullets)
ship.update()
bullets.update()
#get rid of excess bullets
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(gamesettings, screen, ship, aliens, bullets)
def run_game(): #初始化
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)
#创建一个外星人
aliens = Group()
#创建一个用于存储子弹的组
bullets = Group()
#创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
#创建一个用于存储游戏统计信息的实例
stats = GameStats(ai_settings)
#开始游戏的主循环
while True:
gf.check_events(ai_settings, screen, ship, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
#删除屏幕外面的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
def run_game():
# 初始化游戏并创建一个屏幕对象：初始化背景设置,让Pygame能够正确地工作
pygame.init()
pw_settings = Settings()
"""调用pygame.display.set_mode()来创建一个名为screen的显示窗口，
这个游戏的所有图形元素都将在其中绘制。每个元素（如外星人或飞船）都是一个surface对象"""
screen = pygame.display.set_mode(
(pw_settings.screen_width, pw_settings.screen_height))
# 窗口标题
pygame.display.set_caption('Plane War')
# 创建一艘飞船
ship = Ship(pw_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
# 开始游戏的主循环
while True:
gf.check_events(pw_settings, screen, ship, bullets)
ship.update()
bullets.update()
# 删除已消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(pw_settings, screen, ship, bullets)
class BulletManager:
def __init__(self, bullet_stats: BulletStats):
self._bullets = Group()
self._bullet_stats = bullet_stats
def add(self, bullet):
self._bullets.add(bullet)
def update(self, elapsed):
self._bullets.update(elapsed)
# Get rid of bullets that have disappeared
for bullet in self._bullets.copy():
if bullet.rect.bottom <= 0 or bullet.rect.top >= config.screen_height:
self._bullets.remove(bullet)
def empty(self):
self._bullets.empty()
def draw(self, screen):
self._bullets.draw(screen)
def sprites(self):
return self._bullets.sprites()
def __iter__(self):
return self._bullets.__iter__()
def run_game():
# 初始化游戏并建立一个屏幕对象
pygame.init() # 初始化pygame
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)
# 创建一个用于储存炮弹的编组
bullets = Group()
# 开始游戏的主循环
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
# 删除已消失的炮弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
#print(len(bullets))
gf.update_screen(ai_settings, screen, ship, bullets)
def remove(self, *sprites):
for current_sprite in sprites:
if current_sprite not in self: continue
row, col = self.get_cell_row_col(current_sprite)
self.cells[row][col] = None
Group.remove(self, *sprites)
def remove(self, *sprites):
"""Removes as normal but also updates the formation array"""
Group.remove(self, *sprites)
for current_sprite in sprites:
row = current_sprite.row
col = current_sprite.col
self.formation[col][row] = None
if col == self.rightmost_col or col == self.leftmost_col:
self.adjust_borders()
def handle_event(self, event):
if isinstance(event, UpdateEvent):
loop = get_loop()
group = Group(loop.render.sprites())
for member in pygame.sprite.spritecollide(loop.bg_sprite, loop.render, False):
if member in group:
group.remove(member)
for sprite in group:
loop.rm_object(sprite)
pygame.sprite.groupcollide(loop.projectiles, loop.enemies, True, True)
if pygame.sprite.spritecollide(loop.you, loop.enemies, False):
loop.rm_object(loop.you)
lose()
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Zombie Tower Ultimate Sonic The Next Generation Super EX")
play_button = Button(ai_settings, screen, "Play")
# Set the background color
ship = Ship(screen, ai_settings)
bullets = Group()
bomb = Group()
lasercheat = Group()
nuke = Nuke(ai_settings, screen, ship)
block = Block(ai_settings, screen, nuke)
wall = Wall(ai_settings, screen, ship)
lift = Lift(ai_settings, screen, nuke)
aliens = Group()
alien = Alien(ai_settings, screen)
# Start the main loop for the game.
stats = GameStats(ai_settings, bomb, aliens, bullets)
sb = Scoreboard(ai_settings, screen, stats)
gf.create_fleet(ai_settings, screen, ship, aliens)
while True:
# Watch for keyboard and mouse events.
gf.check_events(ai_settings, screen, stats, ship, bullets, lasercheat, aliens, nuke, play_button, bomb, wall, lift)
if stats.game_active:
ship.update()
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bomb, wall)
ai_settings.counterpnts -= 1
if ai_settings.counterpnts <=0:
ai_settings.counterpnts = 60
stats.score += 1
sb.prep_score()
bullets.update()
bomb.update(aliens, ai_settings, screen)
gf.update_screen(ai_settings, screen, stats, sb, ship, bullets, lasercheat, aliens, nuke, play_button, wall, bomb, lift, block)
# Get rid of bullets that have disappeared.
for bullet in bullets.copy():
if bullet.rect.right >= 1200:
bullets.remove(bullet)
print(len(bullets))
class WvmSpritesList():
"""A class listing all the Sprites of the game."""
def __init__(self, config, screen):
"""Initialize the sprite list."""
self.config = config
self.screen = screen
#initialize the sprites
self.wiz = Wizard(config, self)
self.monsters = Group()
self.missiles = Group()
def update_all(self):
"""Update the positions of all sprites."""
self.update_missiles()
self.wiz.update()
self.monsters.update()
def update_missiles(self):
"""update magic missiles positions"""
self.missiles.update()
# remove the missiles that have left the screen
for mi in self.missiles.copy():
if mi.rect.left >= self.screen.get_rect().right:
self.missiles.remove(mi)
def draw(self):
self.screen.fill(self.config.bg_color)
for mi in self.missiles:
mi.draw_missile()
self.wiz.blitme()
for mo in self.monsters:
mo.blitme()
def fire_missile(self):
"""Fire a missile if limit not reached yet."""
if len(self.missiles) < self.wiz.magic_missile_allowed:
self.missiles.add(MagicMissile(self.config, self))
def create_monster(self):
"""Create a new monster and place it randomly at the right."""
monster=Monster(self.config, self)
#TODO move the monster
self.monsters.add(monster)
def run_game():
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)
bullets = Group()
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
bullets.update()
gf.update_screen(ai_settings, screen, ship, bullets)
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
screen.fill(ai_settings.bg_color)
ship.blitme()
pygame.display.flip()
bullets.update()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
class EditorLevel(object):
def __init__(self, editor, level_file=None):
self.editor = editor
self.font_manager = editor.font_manager
if level_file is not None:
(name, player_start, player_direction, board, enemies, powerups) = level_loader.load(level_file)
else:
player_start = None
player_direction = None
board = None
enemies = []
powerups = []
self.board = Board(constants.HORIZONTAL_TILES, constants.VERTICAL_TILES)
for x in xrange(0, constants.HORIZONTAL_TILES):
for y in xrange(0, constants.VERTICAL_TILES):
if board is None:
if x == 0 or y == 0 or x == constants.HORIZONTAL_TILES - 1 or y == constants.VERTICAL_TILES - 1:
tile = Tile("W", Point(x, y))
else:
tile = Tile("G", Point(x, y))
else:
tile = Tile(board.get_tile(x, y).type, Point(x, y))
self.board.set_tile(x, y, tile)
self.tiles = OrderedUpdates([tile for tile in self.board])
self.entities = Group()
if player_start is not None:
player_entity = Entity("PLAYER", editor_constants.ENTITY_DATA_MAP["PLAYER"], player_start, self.font_manager)
player_entity.rotate(player_direction, 1)
self.entities.add(player_entity)
for (position, direction, waypoint_type, waypoints) in enemies:
entity = Entity("ENEMY", editor_constants.ENTITY_DATA_MAP["ENEMY"], position, self.font_manager)
entity.rotate(direction, 1)
actual_waypoints = []
for waypoint in waypoints:
actual_waypoints.append(Entity("WAYPOINT", editor_constants.WAYPOINT_DATA, waypoint, self.font_manager))
entity.waypoints.set_waypoints(actual_waypoints)
self.entities.add(entity)
for powerup in powerups:
entity = Entity(powerup.type, editor_constants.ENTITY_DATA_MAP[powerup.type], powerup.position, self.font_manager)
self.entities.add(entity)
self.toolbars = Group()
vertical_toolbar = VerticalToolbar(self, self.font_manager)
self.toolbars.add(vertical_toolbar)
self.player_exists = bool([entity for entity in self.entities if entity.name == "PLAYER"])
self.entity_to_create = vertical_toolbar.selected.name
self.mode = MODE_ADD
self.rotating = False
self.pending_actions = []
self.action_stack = []
self.undone_action_stack = []
self.selected_entities = []
self.waypoint_entity_selected = None
def add_action(self, action_type, *args):
self.undone_action_stack = []
self.pending_actions.append(action_type(self, *args))
def get_entity(self, position):
data = editor_constants.ENTITY_DATA_MAP[self.entity_to_create]
return Entity(self.entity_to_create, data, position, self.font_manager)
def add_entity(self, entity):
if entity.name == "PLAYER":
self.player_exists = True
self.entities.add(entity)
def remove_entity(self, entity):
if entity.name == "PLAYER":
self.player_exists = False
self.entities.remove(entity)
if entity in self.selected_entities:
entity.select(False)
self.selected_entities.remove(entity)
if entity is self.waypoint_entity_selected:
entity.select(False)
self.waypoint_entity_selected = None
def delete_selection(self):
self.add_action(DeleteSelectionAction, list(self.selected_entities))
def set_selection(self, entities):
self.clear_selection()
for entity in entities:
if not entity in self.entities:
raise Exception("Tried to select non-existent entity.")
entity.select(True)
self.selected_entities.append(entity)
def clear_selection(self):
for entity in self.selected_entities:
entity.select(False)
self.selected_entities = []
def selection_click(self, entity, shift):
if shift:
if entity in self.selected_entities:
entity.select(False)
self.selected_entities.remove(entity)
else:
entity.select(True)
self.selected_entities.append(entity)
else:
if entity in self.selected_entities:
for entity in self.selected_entities:
entity.select(False)
self.selected_entities = []
else:
for other_entity in self.selected_entities:
other_entity.select(False)
entity.select(True)
self.selected_entities = [entity]
def left_click(self, position, pressed):
for toolbar in self.toolbars:
rect = pygame.Rect(toolbar.position, (toolbar.width, toolbar.height))
if rect.collidepoint(position):
toolbar.left_click(position, pressed)
if self.mode == MODE_ADD:
entity = self.get_entity(position)
# make sure the entity doesn't intersect any others
for other_entity in self.entities:
if cd.sprite_collide(entity, other_entity):
return
# make sure the entity creation is in bounds
if not sphere_in_bounds(position, entity.data.ratio / 2, editor_constants.EDITOR_AREA_BOUNDS):
return
if entity.name != "PLAYER" or not self.player_exists:
self.add_action(AddEntityAction, entity)
elif self.mode == MODE_SELECT:
for entity in self.entities:
if entity.contains_point(position):
ctrl = (pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL])
self.selection_click(entity, ctrl)
break
elif self.mode == MODE_TILE:
for tile in self.tiles:
if cd.sprite_contains(tile, position.scale(constants.TILE_SIZE)):
tile.toggle_type()
elif self.mode == MODE_WAYPOINT:
ctrl = (pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL])
if ctrl:
if self.waypoint_entity_selected is not None:
self.add_action(AddWaypointAction, self.waypoint_entity_selected, Entity("WAYPOINT", editor_constants.WAYPOINT_DATA, position, self.font_manager))
else:
for entity in self.entities:
if entity.name == "ENEMY" and entity.contains_point(position):
if self.waypoint_entity_selected is not None:
self.waypoint_entity_selected.select(False)
self.waypoint_entity_selected = entity
entity.select(True)
def switch_mode(self):
if self.mode == MODE_ADD:
self.mode = MODE_SELECT
elif self.mode == MODE_SELECT:
self.clear_selection()
self.mode = MODE_WAYPOINT
elif self.mode == MODE_WAYPOINT:
if self.waypoint_entity_selected is not None:
self.waypoint_entity_selected.select(False)
self.waypoint_entity_selected = None
self.mode = MODE_TILE
elif self.mode == MODE_TILE:
self.mode = MODE_ADD
print self.mode
def start_rotation(self, key):
self.rotating = True
self.total_rotation = 0
for entity in self.selected_entities:
entity.rotating = True
entity.rotation_sign = (1 if key == pygame.K_RIGHT else -1)
self.rotation_key = key
def stop_rotation(self, key):
self.rotating = False
for entity in self.selected_entities:
entity.rotating = False
# directly append to action stack so that we
self.action_stack.append(RotateSelectionAction(self, self.selected_entities, self.total_rotation, (1 if key == pygame.K_RIGHT else -1)))
def update(self, delta, events, pressed, mouse):
if self.rotating:
for event in events:
if event.type == pygame.KEYUP and event.key == self.rotation_key:
self.stop_rotation(event.key)
else:
for event in events:
if event.type == pygame.KEYDOWN and (event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT) and event.mod & pygame.KMOD_CTRL and self.mode == MODE_SELECT and self.selected_entities:
self.start_rotation(event.key)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_m:
self.switch_mode()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_DELETE and self.mode == MODE_SELECT:
self.delete_selection()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_DELETE and self.mode == MODE_WAYPOINT:
if self.waypoint_entity_selected is not None:
self.add_action(DeleteWaypointsAction, self.waypoint_entity_selected)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_y and event.mod & pygame.KMOD_CTRL:
if self.undone_action_stack:
action = self.undone_action_stack.pop()
action.undo = False
self.pending_actions.append(action)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_z and event.mod & pygame.KMOD_CTRL:
if self.action_stack:
action = self.action_stack.pop()
action.undo = True
self.pending_actions.append(action)
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
self.left_click(Point(event.pos[0], event.pos[1]).scale(1.0 / constants.TILE_SIZE), pressed)
elif event.type == pygame.KEYDOWN:
for toolbar in self.toolbars:
toolbar.hotkey(event.key)
for action in self.pending_actions:
action.do()
if action.undo:
self.undone_action_stack.append(action)
else:
self.action_stack.append(action)
self.pending_actions = []
if self.rotating:
self.total_rotation += 2 * math.pi * (delta / 1000.0)
self.entities.update(delta)
def draw(self, screen):
self.tiles.draw(screen)
self.entities.draw(screen)
if self.waypoint_entity_selected is not None:
self.waypoint_entity_selected.draw(screen)
self.toolbars.draw(screen)
for toolbar in self.toolbars:
toolbar.draw(screen)
class Level(object):
fg_color = 0, 0, 0
jungle = load_image("tilegrass.png")
cliff = load_image("tilecliff.png")
lab = load_image("tilemetal.png")
def __init__(self):
self.pups = Group()
self.tiles = Group()
def reset(self):
self.__init__()
def update(self):
for pup in self.pups:
if pup.state == 0 or pup.state == 3:
self.pups.remove(pup)
self.tiles.add(pup)
for pup in self.tiles:
if pup.state == 1 or pup.state == 2:
self.tiles.remove(pup)
self.pups.add(pup)
def draw_hud(self, screen, player):
bounds = screen.get_rect()
pixfont = "./data/fonts/pixelated.ttf"
self.player = player
file_in = open("score.txt","r")
for line in file_in:
self.score = str(line)
self.currentscore = self.score
self.display_score = int(self.currentscore) + int(self.player.scorenum)
font = pygame.font.Font(pixfont, 15)
self.scoredisplay = font.render(("SCORE:"+" "+str(self.display_score)), True, self.fg_color)
rect = self.scoredisplay.get_rect()
rect.center = bounds.centerx - 360, bounds.centery - 160
screen.blit(self.scoredisplay, rect)
if self.wlimit > 0:
self.whistles = font.render(("WHISTLES:"+" "+str(self.wlimit - self.player.whistlecount)), True, self.fg_color)
rect = self.whistles.get_rect()
rect.center = bounds.centerx + 340, bounds.centery - 140
screen.blit(self.whistles, rect)
if self.tlimit > 0:
self.treats = font.render(("TREATS:"+" "+str(self.tlimit - self.player.treatcount)), True, self.fg_color)
rect = self.treats.get_rect()
rect.center = bounds.centerx + 350, bounds.centery - 160
screen.blit(self.treats, rect)
def draw(self, screen, player):
bounds = screen.get_rect()
if self.type == "jungle":
self.bg = load_image("junglebg1.png")
elif self.type == "cliff":
self.bg = load_image("cliffbg.png")
elif self.type == "lab":
self.bg = load_image("labbg.png")
rect = self.bg.get_rect()
rect.center = bounds.centerx, bounds.centery
screen.blit(self.bg, rect)
class EventLoop(object):
def __init__(self):
self.objs = {}
self.events = []
self.render = RenderUpdates()
self.projectiles = Group()
self.enemies = Group()
self.you = None
self.bg_sprite = BGSprite(pygame.display.get_surface())
# Since we don't care about MOST EVENTS
pygame.event.set_allowed(None)
pygame.event.set_allowed([ MOUSEBUTTONDOWN, KEYDOWN, QUIT, UPDATEEVENT, SPAWNEVENT ])
def add_object(self, obj, type=""):
if isinstance(obj, HandlesEvents):
if obj.events == ALL:
try:
self.objs[ALL].append(obj)
except KeyError:
self.objs[ALL] = [ obj ]
else:
for event in obj.events:
try:
self.objs[event].append(obj)
except KeyError:
self.objs[event] = [ obj ]
if isinstance(obj, Sprite):
self.render.add(obj)
if type == "enemy":
self.enemies.add(obj)
if type == "projectile":
self.projectiles.add(obj)
if type == "you":
self.you = obj
def rm_object(self, obj):
for key in self.objs.keys():
self.render.remove(obj)
if obj in self.objs[key]:
self.objs[key].remove(obj)
if self.projectiles.has(obj):
self.projectiles.remove(obj)
if self.enemies.has(obj):
self.enemies.remove(obj)
print "Removed {0}".format(obj)
def enqueue(self, event):
if isinstance(event, Event):
return self.events.append(event)
elif isinstance(event, list):
return [ self.enqueue(ev) for ev in event ]
def tick(self):
try:
event = self.events.pop()
except IndexError:
event = None
if event is not None:
if isinstance(event, TargettedEvent):
event.get_target().handle_event(event)
for obj in self.objs[ALL]:
obj.handle_event(event)
else:
for obj in self.objs[type(event)] + self.objs[ALL]:
if obj.handles_event(event):
obj.handle_event(event)
if random.randint(0, 10000000) == 26:
return win()
if random.randint(0, 10000000) == 26:
return lose()
py_events = map(lambda event: PygameEvent(event), pygame.event.get())
for py_event in py_events:
for obj in reduce(lambda obj_list, obj: obj_list + obj, map(lambda key: self.objs[key], filter(lambda handler_type: issubclass(handler_type, PygameEvent) if handler_type != ALL else False, self.objs.keys())), []):
if obj.handles_event(py_event):
obj.handle_event(py_event)
class Game:
def __init__(self, screen):
self.screen = screen
self.map_screen = self.screen.subsurface(0, 0, MAP_WIDTH, MAP_HEIGHT)
#pygame.display.set_icon(pygame.image.load(os.path.join("images", "ui","icon.png")))
self.loaded_maps = {}
self.current_map = None
pygame.mouse.set_visible(1);
self.hasKey = False
self.animalsFreed = False
self.soundUtil = SoundUtil()
self.soundUtil.sound_on = True
self.pauseMenu = PauseScreen(self)
self.cursor = Sprite()
self.cursor.rect = Rect(0,0,1,1)
self.hud = Hud(self)
self.player_group = Group()
self.player = Taz(image_util.load_image("tasmanian.png"), 1, 1, self)
self.player.inUse = True
self.player.current_image = self.player.image
self.hud.set_player(self.player)
self.last_rendered_achievement = 0
self.achievement_countdown = 0
self.clock = pygame.time.Clock()
self.achievements_done = []
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( True )
self.loadLevel("jail.txt")
self.isGameOver = False
self.returnToMainMenu = False
def reset(self):
self.player_group.remove(self.player)
self.current_map.game_objects.remove(self.player)
self.player = self.player.newPlayer()
self.player.inUse = True
self.player.current_image = self.player.image
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( False )
self.loadLevel("jail.txt")
self.player.x = TILE_SIZE
self.player.y = TILE_SIZE
self.player.rect.left = self.player.x + self.player.left_offset
self.player.rect.top = self.player.y + self.player.top_offset
def loadLevel(self, file):
self.pressed = []
for key in pygame.key.get_pressed():
self.pressed.append( False )
if file in self.loaded_maps:
self.current_map = self.loaded_maps[file]
self.current_map.reset()
else:
self.current_map = Map(file, self.screen, self)
self.loaded_maps[file] = self.current_map
self.current_map.intialize()
def change_maps(self, dest, x, y):
if self.player.isInCar:
self.current_map.game_objects.remove(self.player.car)
self.current_map.not_player.remove(self.player.car)
self.loadLevel(dest)
self.player.x = x * TILE_SIZE
self.player.y = y * TILE_SIZE
self.player.rect.left = self.player.x + self.player.left_offset
self.player.rect.top = self.player.y + self.player.top_offset
if self.player.isInCar:
if isinstance(self.player.car, ImperviousCar):
self.player.car = Car(None,0,0,self)
self.player.car.driver = self.player
self.player.car.driving = True
self.player.car.x = x * TILE_SIZE
self.player.car.y = y * TILE_SIZE
self.player.car.rect.left = self.player.car.x
self.player.car.rect.top = self.player.car.y
self.player.car.avoidMapLinks()
self.current_map.game_objects.add(self.player.car)
elif self.player.isInTree:
self.player.getOutOfTree()
self.player.x = TILE_SIZE
self.player.y = TILE_SIZE
self.player.rect.left = self.player.x + self.player.left_offset
self.player.rect.top = self.player.y + self.player.top_offset
def change_player(self, newPlayer):
self.player.inUse = False
self.player.leave_car()
self.current_map.game_objects.add(self.player)
self.player = newPlayer;
self.player.inUse = True
self.player.current_image = self.player.image
self.hud.set_player(self.player)
def free_all_animals(self):
self.free_animal("Koala")
self.free_animal("Tasmanian Devil")
self.free_animal("Kangaroo")
self.free_animal("Brown Snake")
self.free_animal("Dingo")
def free_animal(self, animal_name):
animals_freed[animal_name] = image_util.load_image(animal_info.info[animal_name][3])
self.hud.draw()
if len(animals_freed) is 5 and self.animalsFreed is False:
cutscene = Cutscene(self, "escape the zoo", \
[image_util.load_image(os.path.join("cutscenes","escape_the_zoo.png"))], \
image_util.load_sliced_sprites(210, 80, os.path.join("cutscenes","press_enter.png")));
cutscene.fire(self.player)
self.animalsFreed = True
def gameloop(self):
self.returnToMainMenu = False
self.hud.draw()
while self.returnToMainMenu is False:
self.clock.tick(60)
self.get_input()
self.update_state()
self.draw()
print "GAME ENDING!"
def achievement(self):
killed = self.hud.visitors_killed
if killed >= 1000 and 1000 not in self.achievements_done:#not killed == self.last_rendered_achievement:
#self.last_rendered_achievement = killed
self.achievements_done.append(1000)
self.achievement_image = image_util.load_image("achievement_1000.png")
self.achievement_countdown = 200
elif killed >= 500 and 500 not in self.achievements_done:## and not killed == self.last_rendered_achievement:
self.achievements_done.append(500)
#self.last_rendered_achievement = killed
self.achievement_image = image_util.load_image("achievement_500.png")
self.achievement_countdown = 200
elif killed >= 100 and 100 not in self.achievements_done:## and not killed == self.last_rendered_achievement:
self.achievements_done.append(100)
#self.last_rendered_achievement = killed
self.achievement_image = image_util.load_image("achievement_100.png")
self.achievement_countdown = 200
elif killed >= 10 and 10 not in self.achievements_done:## and not killed == self.last_rendered_achievement:
self.achievements_done.append(10)
#self.last_rendered_achievement = killed
self.achievement_image = image_util.load_image("achievement_10.png")
self.achievement_countdown = 200
if self.achievement_countdown > 0:
self.screen.blit(self.achievement_image, (250,100))
self.achievement_countdown -= 1
def get_input(self):
self.getEvents()
self.getButtonPresses()
return
def getEvents(self):
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
def getButtonPresses(self):
keys = pygame.key.get_pressed()
# quit
if(keys[K_ESCAPE]):
if not self.pressed[K_ESCAPE]:
self.pressed[K_ESCAPE] = True
self.pauseMenu.loop()
#figure out what we wanted to do
if self.pauseMenu.index is CONTINUE:
self.hud.draw()
elif self.pauseMenu.index is MAIN_MENU:
self.returnToMainMenu = True
else:
self.pressed[K_ESCAPE] = False
# attack
if(keys[K_SPACE]):
if not self.pressed[K_SPACE]:
self.pressed[K_SPACE] = True
self.player.attack()
else:
self.pressed[K_SPACE] = False
# use ability
if(keys[K_RETURN]):
if not self.pressed[K_RETURN]:
self.pressed[K_RETURN] = True
self.player.use_ability()
else:
self.pressed[K_RETURN] = False
# use ability
if(keys[K_F1]):
if not self.pressed[K_F1]:
self.pressed[K_F1] = True
self.free_all_animals()
else:
self.pressed[K_F1] = False
# get into and out of car
if(keys[K_q]):
if not self.pressed[K_q]:
self.pressed[K_q] = True
self.player.use_object()
else:
self.pressed[K_q] = False
# move
if(keys[K_w]):
if not self.pressed[K_w]:
self.player.move(0, -1)
else:
self.pressed[K_w] = False
if(keys[K_s]):
if not self.pressed[K_s]:
self.player.move(0, 1)
else:
self.pressed[K_s] = False
if(keys[K_a]):
if not self.pressed[K_a]:
self.player.move(-1, 0)
else:
self.pressed[K_a] = False
if(keys[K_d]):
if not self.pressed[K_d]:
self.player.move(1, 0)
else:
self.pressed[K_d] = False
if(keys[K_UP]):
if not self.pressed[K_UP]:
self.player.move(0, -1)
else:
self.pressed[K_UP] = False
if(keys[K_DOWN]):
if not self.pressed[K_DOWN]:
self.player.move(0, 1)
else:
self.pressed[K_DOWN] = False
if(keys[K_LEFT]):
if not self.pressed[K_LEFT]:
self.player.move(-1, 0)
else:
self.pressed[K_LEFT] = False
if(keys[K_RIGHT]):
if not self.pressed[K_RIGHT]:
self.player.move(1, 0)
else:
self.pressed[K_RIGHT] = False
if(keys[K_o]):
if not self.pressed[K_o]:
self.pressed[K_o] = True
if self.soundUtil.sound_on:
self.soundUtil.sound_on = False
else:
self.soundUtil.sound_on = True
else:
self.pressed[K_o] = False
def update_state(self):
if self.current_map is not None:
self.current_map.update_objects()
for p in self.player_group:
p.update()
def draw_without_flip(self):
self.map_screen.fill((0,0,0))
if self.current_map is not None:
self.current_map.draw_tiles()
self.current_map.draw_objects()
#for p in self.player_group:
# p.draw()
self.player.draw()
self.achievement()
def draw(self):
self.draw_without_flip()
for cutscene in self.current_map.start_cutscenes:
self.current_map.start_cutscenes.remove(cutscene)
cutscene.fire(self.player)
pygame.display.flip()
class TrySprite(DirtySprite):
""" A sprite class with all the needed things for try-engine.
TrySprite subclasses pygame.sprite.DirtySprite. It adds
some mandatory attributes as col_rect and adds a few methods
to control the render order.
It also has a host-guest sprite thingy that makes sure the host sprite
is updated before the guests sprites. You can attach sprites to sprites
and it will look nice.
TrySprites adds the rects: col_rect, i_rect, feet_rect
dirty_rect, col_rect_left, col_rect_right
TODO: This is probably outdated!
The dirty attribute does NOT mean the same as in pygame. The
meaning is:
0 = The srpite has been drawn in this frame
1 = hasn't been drawn in this frame yet
2 = nothing at the moment
"""
def __init__(self, img, x, y, col_rect):
DirtySprite.__init__(self)
self.image = img
self.rect = Rect((x,y),self.image.get_rect()[2:])
self.visible = 1
self.dirty = 1
# Directions in which this sprite collide
self.col_direction = (True, True, True, True)
# Has this sprite sprites attached to him? or the opposite
# If this is used the guest sprite will be always updated
# after the host sprite.
self.guest = False
self.guests = Group()
self.host = None
# Create all the needed rects:
self.init_rects(self.rect, col_rect)
# Init mask
self.init_masks()
# if True will print lots of debugging stuff
self.debugging = False
def init_rects(self, rect, col_rect):
""" Create all the rects needed for the sprite
Creates: collision rect, feet rect, interpolation rect,
dirty rect and collision mask.
"""
# List holding all the rects, allow for fast iteration
# over all the rects
self.rect_list = rl = []
rl.append(self.rect)
# Rect used for collisions
self.col_rect = col_rect.copy().move(rect[:2])
rl.append(self.col_rect)
# Used to know where was the last interpolated position
# TODO: do we use this????
self.i_rect = rect.copy()
rl.append(self.i_rect)
# Rect to clear this sprite when drawing
self.dirty_rect = rect.copy()
rl.append(self.i_rect)
# Create a rect representing the feet
self.feet_rect = self.create_feet()
rl.append(self.feet_rect)
# Create left and right collision rects
self.col_rect_left, self.col_rect_right = self.create_left_right()
rl.append(self.col_rect_left)
rl.append(self.col_rect_right)
def create_feet(self):
""" Creates a pygame Rect that will represent the feet. """
cr = self.col_rect
# One pixel height rect at the feet, overlapping the col_rect
# PLEASE NOTE: Any additional rect used for collisions needs to
# be contained by col_rect, if not bad things happens (colision
# is detected by one rect but no the other and both are used in
# orther to collide with all the platforms). That is way the
# -1 is needed in cr.bottom.
return Rect(cr.left, cr.bottom - 1, cr.width, 1)
# TODO: This has a problem with col_rects the same size as the
# normal rect
def create_left_right(self):
""" Creates two rects each one being a half of col_rect.
These rects are used to detect which side of the sprites
touches something.
"""
cr = self.col_rect
col_rect_left = Rect(cr.left, cr.top, cr.width /2 , cr.height)
col_rect_right = Rect(cr.left + cr.width/2, cr.top, cr.width /2, cr.height)
return col_rect_left, col_rect_right
def init_masks(self):
""" Init the mask for the sprite.
NOTE: any additional rect created must be, in general, inside
of col_rect. That way collisions will work properly
"""
# Create a mask with the image
# TODO, NOTE TO SELF: The mask will use the first frame
# in the animation! ALWAYS
self.mask = mask.from_surface(self.image)
#~ self.view_mask()
# Feet mask
self.feet_mask = mask.Mask((self.rect.width, 1))
h = self.rect.height
s_at = self.feet_mask.set_at
g_at = self.mask.get_at
for x in xrange(self.rect.width):
if g_at((x, h - 1)):
s_at((x, 0), 1)
#~ @property
#~ def dirty(self):
#~ return self._dirty
#~
#~ @dirty.setter
#~ def dirty(self, value):
#~ if self.dirty == 1:
#~ old = self.dirty_rect
#~ else:
#~ old = self.rect
#~ self.dirty_rect = old.union(self.rect)
#~ self._dirty = value
def add_guest(self, sprite):
""" Add a guest sprite to this sprite.
The guest sprite will be updated after the host.
"""
self.guests.add(sprite)
sprite.guest = True
sprite.host = self
def remove_guest(self, sprite):
""" Remove a guest sprite to this sprite. """
self.guests.remove(sprite)
sprite.guest = False
sprite.host = None
def add_host(self, sprite):
""" Add a host for this sprite.
This sprite will be updated after the host sprite.
"""
self.host = sprite
self.guest = True
sprite.guests.add(self)
def remove_host(self):
""" Remove a host from this sprite. """
self.host.guests.remove(self)
self.host = None
self.guest = False
def one_layer_down(self):
""" Moves the sprite one layer down in the render group.
This will make the sprite be seen below other sprites
in the same group.
"""
for g in self.groups():
if isinstance(g, TryGroup):
g.one_layer_down(self)
def one_layer_up(self):
""" Moves the sprites one layer up in the render group.
This will make the sprite be seen over other sprites
in the same group.
"""
for g in self.groups():
if isinstance(g, TryGroup):
g.one_layer_up(self)
def move_ontop(self, ref_sprite):
""" Move this sprite just on top of ref_sprite in render order. """
for g in self.groups():
if isinstance(g, TryGroup):
g.ref_render_order_change(ref_sprite, self, 0)
def move_below(self, ref_sprite):
""" Move this sprite just below of ref_sprite in render order. """
for g in self.groups():
if isinstance(g, TryGroup):
g.ref_render_order_change(ref_sprite, self, 1)
def properly_add_ontop(self, sprite):
""" Add a new sprite on top of this one.
sprite will be added to all the groups in which self is
and when in render groups, it will be added on top of
self.
"""
for g in self.groups():
if isinstance(g, TryGroup):
g.add_ontop(self, sprite)
else:
g.add(sprite)
def properly_add_below(self, sprite):
""" Add a new sprite below of this one.
sprite will be added to all the groups in which self is
and when in render groups, it will be added below of
self.
"""
for g in self.groups():
if isinstance(g,TryGroup):
g.add_below(self, sprite)
else:
g.add(sprite)
def change_sprite_pos(self, x, y):
""" Changes the sprite position to x, y.
Move all the needed rects to the new x, y position.
"""
rect = self.rect
dx, dy = x - rect.left, y - rect.top
self.move_sprite(dx, dy)
def move_sprite(self, delta_x, delta_y):
""" Changes the sprite position by delta_x, delta_y.
Move all the needed rects by delta_x, delta_y
"""
rect = self.rect.copy()
dirty_rect = self.dirty_rect
# TODO: with movements mods this is probably outdated.
# All movement is made at the same moment.
# Note to self: This if-else is needed to clean old sprite
# positions when two movements are done in the same frame,
# for example, teleporting/respawning
# if self.dirty == 1:
# old = dirty_rect
# else:
# old = rect
old = rect
# Move rects
[r.move_ip(delta_x, delta_y) for r in self.rect_list]
# Update dirty stuff
self.dirty_rect = old.union(rect)
self.dirty = 1
def move_sprite_float(self, delta_x, delta_y):
""" Move the sprite a float amount
Uses the integer part to move the sprite and stores
the float part in a variable.
"""
self.fx += delta_x
self.fy += delta_y
self.fx, dx = modf(self.fx)
self.fy, dy = modf(self.fy)
# move rects
self.move_sprite(dx, dy)
def dprint(self,text):
""" If debugging is True it will print debug text. """
if self.debugging:
print text
def _view_mask(self):
""" Prints the sprite mask to the terminal and exits
For debugging purposes.
"""
print self
print "Printing mask and exiting."
for y in xrange(self.mask.get_size()[1]):
for x in xrange(self.mask.get_size()[0]):
print self.mask.get_at((x,y)),
print ""
sys.exit(0)
class ObstacleManager:
obstacle_types = {Beer: 89,
Nyan: 2,
EnergyDrink: 3,
HealthPack: 4,
Vodka: 10
}
obstacles = []
counter = 0
default_speed = 0
def __init__(self, gameboard, speed, max_obstacles, collision_strategy_factory, player):
self.max_obstacles = max_obstacles
self.gameboard = gameboard
self.width = gameboard.width
self.height = gameboard.height
self.speed = speed
self.default_speed = speed
self.obstacle_group = Group()
self.collision_strategy_factory = collision_strategy_factory
self.player = player
def update(self, time_passed):
delete_list = []
for obstacle in self.obstacles:
if obstacle.y > self.height:
delete_list.append(obstacle)
else:
obstacle.update(time_passed)
for obstacle in delete_list:
self.obstacles.remove(obstacle)
obstacle.kill()
def blit(self):
for obstacle in self.obstacles:
obstacle.blit()
def create_obstacle(self):
if len(self.obstacles) <= self.max_obstacles:
self.counter += 1
if self.counter % 10 == 0:
obstacle = self.__select_obstacle_type()(self.gameboard,
(random.randint(0, self.width), -40),
self.speed * (1 + (random.random()-0.5) * 0.2))
self.obstacles.append(obstacle)
self.obstacle_group.add(obstacle)
def __select_obstacle_type(self):
total = sum(w for c, w in self.obstacle_types.items())
r = random.uniform(0, total)
upto = 0
for c, w in self.obstacle_types.items():
if upto + w > r:
return c
upto += w
def detect_collision(self):
collisions = spritecollide(self.player, self.obstacle_group, True)
for c in collisions:
self.collision_strategy_factory.get_strategy(c).on_collision()
self.obstacles.remove(c)
c.kill()
def accelerate_obstacles(self, speed):
self.speed += speed
if self.speed > 1.5:
self.speed = 1.5
def reset(self):
self.speed = self.default_speed
for obstacle in self.obstacles:
obstacle.kill()
self.obstacle_group.remove(obstacle)
self.obstacles = []
class LumberjackGame(Microgame):
def __init__(self):
# TODO: Initialization code here
Microgame.__init__(self)
self.jack = Man()
self.count = 0
self.mycount = pygame.font.SysFont("arial", 50, bold = True)
self.left, self.left_rect = _load_image(join("games","Lumberjack","images","timberman_normalleft.png"), 105, 400)
self.left_chop, self.leftc_rect = _load_image(join("games","Lumberjack","images","timberman_chopleft.png"), 130, 450)
self.right, self.right_rect = _load_image(join("games","Lumberjack","images","timberman_normalright.png"), 500, 400)
self.right_chop, self.rightc_rect = _load_image(join("games","Lumberjack","images","timberman_chopright.png"), 375, 450)
self.stump = load(join("games","Lumberjack","images","stump.png"))
self.sprites = Group(self.jack)
self.background = load(join("games","Lumberjack","images","forest.png"))
self.tree = Group(treeBlock(LEFT_POSITION, 550, 1))
def start(self):
# TODO: Startup code here
music.load(join("games","Lumberjack","music","tree_song.ogg"))
music.play()
self.generateTree()
def stop(self):
# TODO: Clean-up code here
music.stop()
def generateTree(self):
_ , min_y = self.tree.sprites()[len(self.tree.sprites()) - 1].rect.topleft
cur_tree = 0
for n in range(0, (len(self.tree.sprites()) - 1)):
_ , y = self.tree.sprites()[n].rect.topleft
if y < min_y:
min_y = y
cur_tree = n
if min_y > 0 and min_y <= 550:
tree_type = self.tree.sprites()[cur_tree].type
if tree_type == 2:
self.tree.add(treeBlock(LEFT_POSITION, (min_y - 140), randint(1,2)))
elif tree_type == 0:
self.tree.add(treeBlock(LEFT_POSITION, (min_y - 140), randint(0,1)))
else:
self.tree.add(treeBlock(LEFT_POSITION, (min_y - 140), randint(0,2)))
def updateTree(self, side):
max_y = locals.HEIGHT
cur_tree = 0
for n in range(0, (len(self.tree.sprites()))):
_ , y = self.tree.sprites()[n].rect.topleft
if 550 == y:
max_y = y
cur_tree = n
print max_y, self.tree.sprites()[cur_tree].type
if self.tree.sprites()[cur_tree].type == side:
self.lose()
else:
self.tree.remove(self.tree.sprites()[cur_tree])
#self.tree.update()
for each in self.tree:
each.update()
def update(self, events):
# TODO: Update code here
self.sprites.update()
self.generateTree()
#Process user input
sound_chop = pygame.mixer.Sound(join("games","Lumberjack","music","axe_chop.wav"))
if self.jack.image == self.left_chop:
self.jack.image = self.left
self.jack.rect = self.left_rect
elif self.jack.image == self.right_chop:
self.jack.image = self.right
self.jack.rect = self.right_rect
for event in events:
if event.type == KEYDOWN and event.key == K_LEFT:
self.count += 1
sound_chop.play()
self.jack.image = self.left_chop
self.jack.rect = self.leftc_rect
self.updateTree(2)
elif event.type == KEYDOWN and event.key == K_RIGHT:
self.count += 1
sound_chop.play()
self.jack.image = self.right_chop
self.jack.rect = self.rightc_rect
self.updateTree(0)
def render(self, surface):
# TODO: Rendering code here
surface.fill(Color(255, 255, 255))
surface.blit(self.background, (0, 0), area = None, special_flags = 0)
self.tree.draw(surface)
surface.blit(self.stump, (318, 690), area = None, special_flags = 0)
self.sprites.draw(surface)
label = self.mycount.render(str(self.count), 1, (255, 255, 255))
if self.count <= 9:
surface.blit(label, (398, 200))
else:
surface.blit(label, (385, 200))
def get_timelimit(self):
# TODO: Return the time limit of this game (in seconds, 0 <= s <= 15)
#raise NotImplementedError("get_timelimit")
return 15
class Game:
def __init__(self,
demo,
birds,
screen,
menu):
self.demo = demo
self.demo_timeout = 45000
self.screen = screen
self.ctrl = GameControl()
self.clock = pygame.time.Clock()
self.menu = menu
self.menu.cursor_pos = 0
if demo:
pygame.mixer.music.load(media.random_silly_chip_song_file)
pygame.mixer.music.play()
else:
pygame.mixer.music.load(media.Grey_Sector_v0_86_0_file)
pygame.mixer.music.play(-1)
self.bg_explode = 0
self.bg_color = (0, 0, 0)
self.ui = ui.UI()
self.birds = []
self.mainchar = GreenBird(self)
self.birds.append(self.mainchar)
bird2 = RedBird(self)
self.birds.append(bird2)
if birds >= 3:
bird3 = PurpleBird(self)
self.birds.append(bird3)
if birds == 4:
bird4 = CyanBird(self)
self.birds.append(bird4)
if demo:
self.mainchar.brain = BirdBrain(self.mainchar, self.birds)
bird2.brain = BirdBrain(bird2, self.birds)
if birds >= 3:
bird3.brain = BirdBrain(bird3, self.birds)
if birds == 4:
bird4.brain = BirdBrain(bird4, self.birds)
self.bombs = Group()
for b in self.birds:
b.move.add(self.ui.tiles)
self.lives = ui.LifeCounter(self.birds, self.screen)
def start(self):
while self.ctrl.keepPlaying:
for e in pygame.event.get():
if self.demo or self.menu.game_over:
self.manage_keys_demo(e)
else:
self.manage_keys_normal(e)
if e.type == pygame.QUIT:
self.ctrl.keepPlaying = False
self.ctrl.quit = True
if self.ctrl.leftKeyDown:
self.mainchar.moveleft(tick)
if self.ctrl.rightKeyDown:
self.mainchar.moveright(tick)
if self.ctrl.upKeyDown:
self.mainchar.thrust(tick)
tick = self.clock.tick()
if self.bg_explode > 0:
if self.bg_explode % 2 == 0:
self.bg_color = (255, 255, 255)
else:
self.bg_color = (0, 0, 0)
self.bg_explode -= 1
elif self.bg_explode == 1:
self.bg_explode = 0
self.bg_color = (0, 0, 0)
self.screen.fill(self.bg_color)
self.update(tick)
pygame.display.update()
pygame.time.delay(16)
pygame.mixer.music.stop()
def manage_keys_normal(self, e):
if e.type == pygame.KEYDOWN:
if e.key == pygame.K_a:
self.ctrl.leftKeyDown = True
elif e.key == pygame.K_d:
self.ctrl.rightKeyDown = True
elif e.key == pygame.K_w:
self.ctrl.upKeyDown = True
elif e.type == pygame.KEYUP:
if e.key == pygame.K_a:
self.ctrl.leftKeyDown = False
elif e.key == pygame.K_d:
self.ctrl.rightKeyDown = False
elif e.key == pygame.K_w:
self.ctrl.upKeyDown = False
elif e.key == pygame.K_ESCAPE:
self.ctrl.keepPlaying = False
self.ctrl.quit = True
elif e.key == pygame.K_SPACE:
self.mainchar.nuke()
def manage_keys_demo(self, e):
if e.type == pygame.KEYUP:
if not self.menu.game_over:
if e.key == pygame.K_1:
gl.RESIZE_FACTOR = 1
media.load_all_images()
self.ctrl.keepPlaying = False
self.ctrl.reset_demo = True
elif e.key == pygame.K_2:
gl.RESIZE_FACTOR = 2
media.load_all_images()
self.ctrl.keepPlaying = False
self.ctrl.reset_demo = True
elif e.key == pygame.K_3:
gl.RESIZE_FACTOR = 3
media.load_all_images()
self.ctrl.keepPlaying = False
self.ctrl.reset_demo = True
if e.key == pygame.K_ESCAPE:
self.ctrl.keepPlaying = False
self.ctrl.quit = True
elif e.key == pygame.K_SPACE:
if not self.menu.next_screen() or self.menu.game_over != 0:
self.ctrl.keepPlaying = False
elif e.key == pygame.K_UP or e.key == pygame.K_w:
self.menu.cursor_up()
elif e.key == pygame.K_DOWN or e.key == pygame.K_s:
self.menu.cursor_down()
def add_bomb_event(self, bomb):
self.bombs.add(bomb)
bomb.explode_event = self.explode_event
bomb.delete_bomb = self.delete_bomb
def explode_event(self, bomb):
self.bg_explode = 10
distance = math.sqrt(
abs(bomb.rect.centerx - self.ui.tntcrate.rect.centerx)**2 +
abs(bomb.rect.centery - self.ui.tntcrate.rect.centery)**2)
if distance <= 56 * gl.RESIZE_FACTOR:
self.ui.tntcrate.explode(bomb.bird)
for b in self.bombs:
if b is bomb:
continue
distance = math.sqrt(
abs(bomb.rect.centerx - b.rect.centerx)**2 +
abs(bomb.rect.centery - b.rect.centery)**2)
if distance <= 24 * gl.RESIZE_FACTOR and not b.exploded:
b.explode()
for b in self.birds:
distance = math.sqrt(
abs(bomb.rect.centerx - b.rect.centerx)**2 +
abs(bomb.rect.centery - b.rect.centery)**2)
if distance <= 24 * gl.RESIZE_FACTOR:
b.kill()
def delete_bomb(self, bomb):
self.bombs.remove(bomb)
def update(self, tick):
for t in self.ui.bg:
t.update(tick)
self.screen.blit(t.image, pygame.rect.Rect(t.rect.x, t.rect.y, t.rect.w, t.rect.h))
for t in self.ui.tiles:
self.screen.blit(t.image, pygame.rect.Rect(t.rect.x, t.rect.y, t.rect.w, t.rect.h))
for b in self.birds:
b.update(tick)
if b.counter_invincible <= 0 or not b.invisible:
self.screen.blit(b.image, pygame.rect.Rect(b.rect.x, b.rect.y, b.rect.w, b.rect.h))
b.invisible = not b.invisible
for bomb in self.bombs:
bomb.update(tick)
self.screen.blit(bomb.image, pygame.rect.Rect(bomb.rect.x, bomb.rect.y, bomb.rect.w, bomb.rect.h))
if bomb.attached:
continue
for b in self.birds:
if b is bomb.bird or b.dead:
continue
distance = math.sqrt(
abs(bomb.rect.centerx - b.rect.centerx)**2 +
abs(bomb.rect.centery - b.rect.centery)**2)
if distance <= 8 * gl.RESIZE_FACTOR:
bomb.explode()
if self.demo:
self.menu.update(tick)
self.demo_timeout -= tick
if self.demo_timeout < 0:
self.ctrl.keepPlaying = False
self.ctrl.reset_demo = True
else:
self.lives.update(tick)
if self.mainchar.lives == 0:
self.menu.game_over = 1
self.menu.update(tick)
alives = 0
for b in self.birds:
if b.lives > 0:
alives += 1
if alives == 1 and self.mainchar.lives > 0:
self.menu.game_over = 2
self.menu.update(tick)
elif alives == 0:
self.menu.game_over = 3
self.menu.update(tick)
class Scoreboard:
def __init__(self, game_settings, screen, stats):
self.game_setting = game_settings
self.screen = screen
self.screen_rect = screen.get_rect()
self.stats = stats
self.text_color = (30, 255, 30)
self.font = pygame.font.SysFont(None, 48)
self.score_rect = None
self.score_string = None
self.score_image = None
self.high_score_image = None
self.high_score_rect = None
self.level_rect = None
self.level_image = None
self.prep_score()
self.prep_high_score()
self.prep_level()
self.ships = Group()
def prep_score(self):
rounded_score = int(round(self.stats.score, -1))
self.score_string = "{:,}".format(rounded_score)
self.score_image = self.font.render(self.score_string, True, self.text_color, self.game_setting.bg_color)
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_high_score(self):
high_score = int(round(self.stats.high_score, -1))
high_score_string = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_string, True, self.text_color, self.game_setting.bg_color)
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def prep_level(self):
self.level_image = self.font.render(str(self.stats.level), True, self.text_color,
self.game_setting.bg_color)
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
for ship_number in range(self.stats.ships_left):
ship = IconShip(self.game_setting, self.screen)
ship.rect.x = 10 + ship_number * (ship.rect.width / 2)
ship.rect.y = 10
self.ships.add(ship)
def remove_ships(self):
self.ships.remove(self.ships, self)
def show_score(self):
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
