def __init__(self, isfullscreen=False):
pygame.init()
self.settings = Settings()
self.status = GameStatus(self)
if not isfullscreen:
self.screen = pygame.display.set_mode(
(self.settings.width, self.settings.height)) #character
else:
self.screen = pygame.display.set_mode()
self.settings.width = self.screen.get_rect().width
self.settings.width = self.screen.get_rect().height
self.screen_rect = self.screen.get_rect()
self.button = Button(self, "Play")
self.scoreboard = ScoreBoard(self)
pygame.display.set_caption("外星人入侵 v3.0")
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.autofire = False
self.aliens = pygame.sprite.Group()
self.isboss_flag = False
self.alien_boss = AlienBoss(self)
self.boss_bullets = pygame.sprite.Group()
self.boss_skill_num = self.settings.bullet_boss_skill_num
self.props = pygame.sprite.Group()
self.count = 0
self.count2 = 0
def get_game_statuses(self, sql_dao):
urls = self.build_urls()
game_statuses = []
for day, url in urls.items():
print('Checking {} ...'.format(day))
try:
request = Request(url, headers={'User-Agent': "Magic Browser"})
connection = urlopen(request)
soup = BeautifulSoup(connection, 'html.parser')
game_status_button = soup.find('a',
attrs={'class': 'more-info'})
is_game_sold_out = bool(
game_status_button
and self.SOLD_OUT in game_status_button.text)
game_status = GameStatus(day, url, is_game_sold_out, sql_dao)
game_statuses.append(game_status)
game_status.set_prior_game_availability()
# If this game never existed lets insert it.
if game_status.was_game_sold_out is None:
game_status.insert_game()
except Exception as e:
game_status = GameStatus(day, url, None, sql_dao)
game_statuses.append(game_status)
print("All Hockey Games: ")
print(sql_dao.get_hockey_games())
return game_statuses
def run():
pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("catch ball")
bg_color = (255, 255, 255)
ship = Ship(screen)
function = BallFunctions()
b = Group()
ship = Group()
game_status = GameStatus()
while True:
game_status.check_active()
if game_status.game_active:
function.update_screen(screen, ship, bg_color, b, game_status)
else:
sys.exit()
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")
# 创建统计信息的实例
status = GameStatus(ai_settings)
# 创建飞船
ship = Ship(ai_settings, screen)
# alien = Alien(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, status, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
def run_game():
#init pygame, settings and screen
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 = GameStatus(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats)
#create a ship
ship = Ship(ai_settings, screen)
#create alien groups
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
#create bullet groups
bullets = Group()
#game main loop
while True:
#monitor keyboard and mouse event
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
#update bullets first to check if bullets meet any alien
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, stats, screen, sb, ship, aliens,
bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, 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')
# 创建play按钮
play_button=Button(ai_settings,screen,"Play")
#设置背景色
ai_settings.bg_color=(230,230,230)
#创建一个飞船
ship=Ship(ai_settings,screen)
#创建一个用于存储子弹的元组
bullets=Group()
#创建一个外星人
alien=Alien(ai_settings,screen)
#创建一个外星人编组，储存所有的外星人
aliens=Group()
gf.create_fleet(ai_settings,screen,ship,aliens)
#创建一个用于存储游戏统计信息的实例,和计分板
stats=GameStatus(ai_settings)
sb=Scoreboard(ai_settings,screen,stats)
#开始游戏主循环
while True:
gf.check_events(ai_settings,screen,stats,play_button,ship,aliens,bullets)
gf.update_screen(ai_settings,screen,stats,sb,ship,aliens,bullets,play_button)
if stats.game_active==True:
ship.update()
gf.update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets)
gf.update_aliens(ai_settings,stats,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("Super Mario")
# 创建马里奥
mario = Mario(screen, ai_settings)
# 创建一个用于存储游戏统计信息的实例
status = GameStatus(ai_settings)
# 创建一个蘑菇
mushroom = Mushroom(screen, ai_settings, status)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(mario)
if status.game_active:
mario.update()
gf.check_mario_mushroom_collisions(mario, mushroom)
mushroom.update(status)
gf.update_screen(ai_settings, screen, mario, mushroom)
def run_game():
# init
pygame.display.set_caption("Alien Invasion")
pygame.init()
gameSettings = Settings()
# 创建一个用于存储游戏统计信息的实例
status = GameStatus(gameSettings)
screen = pygame.display.set_mode(
(gameSettings.screen_width, gameSettings.screen_height))
sb = Scoreboard(gameSettings, screen, status)
# create the ship
ship = Ship(gameSettings, screen)
# create a group to store bullet
bullets = Group()
# create an alien
aliens = Group()
gf.create_fleet(gameSettings, screen, aliens, ship)
# 创建Play按钮
play_button = Button(gameSettings, screen, "Play")
while True:
# check the event
gf.check_events(gameSettings, screen, ship, bullets, status,
play_button, aliens, sb)
# update the ship and bullets
if status.game_active:
ship.update()
gf.update_bullets(aliens, bullets, screen, ship, gameSettings,
status, sb)
gf.update_aliens(gameSettings, aliens, ship, status, screen,
bullets, sb)
# update the screen
gf.update_screen(gameSettings, screen, ship, bullets, aliens, status,
play_button, sb)
def run_game():
pygame.init()
settings = Settings()
os.environ["SDL_VIDEO_WINDOW_POS"] = "%d, %d" % (settings.screen_left,
settings.screen_top)
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption('外星人入侵')
ship = Ship(screen, settings.ship_speed_factor)
bullets = Group()
aliens = Group()
gf.creat_aliens(aliens, screen, settings)
status = GameStatus(settings)
game_info = GameInfo(screen, ship, settings, 0, len(aliens), status)
buttons = Buttons(screen)
pop_msg = ScreenPopMsg(screen)
while True:
gf.check_events(screen, ship, aliens, settings, bullets, buttons,
status, game_info)
gf.check_game_status(status)
if status.game_alive == 2:
gf.check_game_hit(ship, aliens, bullets, status,
settings.screen_height, game_info)
ship.update()
gf.update_bullets(bullets)
gf.update_aliens(aliens, bullets, screen, settings,
status.game_alive)
game_info.prep_statusbar(len(bullets), len(aliens))
gf.check_fire(bullets, aliens, settings, status, game_info)
gf.update_screen(settings, screen, ship, game_info, bullets, aliens,
buttons, status, pop_msg)
def run_game():
pygame.init()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alion Tnvasion')
play_button = Button(screen, 'Play')
status = GameStatus(ai_settings)
sb = ScoreBoard(ai_settings, screen, status)
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, status, ship, aliens, bullets,
play_button, sb)
if status.game_active == True:
ship.update()
gf.update_bullets(ai_settings, screen, status, ship, aliens,
bullets, sb)
gf.update_aliens(ai_settings, screen, status, ship, aliens,
bullets, sb)
gf.update_screen(ai_settings, screen, status, ship, aliens, bullets,
play_button, sb)
def run_game():
"""#初始化游戏并创建一个屏幕对象"""
setting = Settings()
pygame.init()
screen = pygame.display.set_mode(
(setting.screen_width, setting.screen_height))
pygame.display.set_caption("Alien Invasion")
#创建一个用于存储游戏的统计信息的实例
status = GameStatus(setting)
sb = Scoreboard(setting, screen, status)
"""创建一艘飞船"""
ship = Ship(setting, screen)
bullets = Group()
stars = Group()
aliens = Group()
gf.addGroupStars(setting, screen, stars)
"""创建外星人群"""
gf.create_fleet(setting, screen, ship, aliens)
#创建play按钮
playBtn = Button(setting, screen, "play")
#开始游戏的主循环
while True:
#监视键盘和鼠标事件
gf.check_events(setting, screen, ship, status, aliens, bullets,
playBtn, sb)
if status.game_active:
ship.update() #更新飞船的位置
gf.update_bullets(setting, screen, ship, aliens, bullets, status,
sb)
gf.update_aliens(setting, status, screen, ship, aliens, bullets,
sb)
#刷新屏幕
gf.update_screen(setting, screen, ship, aliens, bullets, stars, status,
playBtn, sb)
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()
# 创建一个外星人
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
# 创建一个用于存储游戏统计信息的实例，并创建记分牌
status = GameStatus(ai_settings)
sb = ScoreBoard(ai_settings, screen, status)
# 创建Play按钮
play_button = Button(ai_settings, screen, "Play")
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, status, sb, play_button, ship,
aliens, bullets)
if status.game_active:
ship.update()
gf.update_aliens(ai_settings, screen, status, sb, ship, aliens,
bullets)
gf.update_bullets(ai_settings, screen, status, sb, ship, aliens,
bullets)
gf.update_screen(ai_settings, screen, status, sb, ship, aliens,
bullets, play_button)
def run_game():
'''初始化屏幕并创建一个屏幕对象'''
pygame.init()
ai_set = Setting()
screen = pygame.display.set_mode(
(ai_set.screen_width, ai_set.screen_height))
pygame.display.set_caption('Alien Invasion')
# bg_color = (230,230,230)
# 创建一艘飞船、一个子弹编组和一个外星人编组
ship = Ship(ai_set, screen)
bullets = Group()
aliens = Group()
#创建外星人实例
gf.create_fleet(ai_set, screen, ship, aliens)
#创建一个用于存储游戏统计信息的实例
status = GameStatus(ai_set)
sb = Scoreboard(ai_set, screen, status)
#创建play按钮
play_button = Button(ai_set, screen, 'Play')
#
#游戏主循环开始
while True:
#监控键盘和鼠标事件
gf.check_events(ai_set, screen, ship, bullets, status, play_button,
aliens, sb)
if status.game_active:
ship.update()
gf.update_bullets(ai_set, screen, ship, aliens, bullets, status,
sb)
gf.update_aliens(aliens, ai_set, ship, status, bullets, screen, sb)
gf.update_screen(ai_set, screen, ship, aliens, bullets, play_button,
status, sb)
def __init__(self, difficulty, square_size):
"""Konstruktori, joka luo GameLoop-olion.
Args:
difficulty (Difficulty): Vaikeustaso-olio, joka kertoo peliruutujen määrän ja
sen myötä pelinäytön koon yhdessä peliruudukon ruutujen koon kanssa.
square_size (int): Kokonaisluku, joka kertoo yhden peliruudun koon.
"""
self._difficulty = difficulty
self._square_size = square_size
self._gameview = None
self._display = None
self._game_status = GameStatus()
self._scores_service = ScoresService()
self._stop = None
self._clock = None
self._build_game()
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init();
ai_setting = Setting();
screen = pygame.display.set_mode((ai_setting.screen_width,ai_setting.screen_height));
pygame.display.set_caption("alien_invasion");
#创建play按钮
play_button = Button(ai_setting,screen,"Play");
#创建一个用于存储游戏统计信息的实例
status = GameStatus(ai_setting);
#创建计分实例
sb = ScoreBoard(ai_setting,screen,status);
#创建一艘飞船
ship = Ship(ai_setting,screen);
#创建一个外星人
#alien = Alien(ai_setting,screen);
#创建一个用于存放子弹的组
bullets = Group();
#设置背景色
#bg_color = (230,230,230);
#创建一个用于存放外星人的组
aliens = Group();
#创建外星人群
gf.create_fleet(ai_setting,screen,ship,aliens);
#开始游戏主循环
while True:
#监视键盘和鼠标事件
gf.check_events(ai_setting,screen,status,sb,play_button,ship,aliens,bullets);
#还有飞船的时候更新
if status.game_active:
#更新飞船位置
ship.update();
#更新外星人位置
gf.update_aliens(ai_setting,status,sb,screen,ship,aliens,bullets);
#更新子弹信息
gf.update_bullets(ai_setting,screen,status,sb,ship,aliens,bullets);
#刷新屏幕
gf.update_screen(ai_setting,screen,status,sb,ship,aliens,bullets,play_button);
def __init__(self):
pygame.init()
self.my_setting = Settings()
self.screen = pygame.display.set_mode(
(self.my_setting.screen_width, self.my_setting.screen_height))
pygame.display.set_caption('Alien Invasion')
self.color = self.my_setting.bg_color
'''放在初始化完成下面'''
self.ship = Ship(self)
'''子弹'''
self.bullets = pygame.sprite.Group()
self.is_bulleting = False
'''外星人'''
self.aliens = pygame.sprite.Group()
self._build_aliens()
'''游戏状态'''
self.status = GameStatus(self)
'''play按钮'''
self.play_button = Button(self, 'Play')
'''分数按钮'''
self.sb = ScoreBoard(self)
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width,
ai_settings.screen_height)) # ((width,height),x,y)默认0,0
pygame.display.set_caption("《外星人入侵》")
# 创建开始按钮
play_button = Button(ai_settings, screen, "开始游戏")
# pygame.font.get_fonts(),输出本机自带的字体
# # 创建存储游戏统计信息的实例，并创建记分牌
status = GameStatus(ai_settings)
sb = Scoreboard(ai_settings, screen, status)
# 创建一艘飞船
ship = Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
# 创建一个用于存储外星人的编组
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 创建外星人爆炸帧动画
explosion = Group()
# 创建飞船爆炸帧动画
destroyed = Group()
# 随机产生一个背景
once = True
# 开始游戏的主循环
while True:
gf.check_events(ai_settings, screen, status, sb, play_button, ship,
aliens, bullets)
if status.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, status, sb, ship, aliens,
bullets, explosion)
gf.update_aliens(ai_settings, screen, status, sb, ship, aliens,
bullets, explosion, destroyed)
gf.update_screen(ai_settings, screen, status, sb, ship, aliens,
bullets, explosion, destroyed, play_button, once)
def test_if_difficulties_have_right_sizes_and_amoud_of_mines(self):
self.random_view.push_left_button(0, 0)
height1 = self.random_view.height
width1 = self.random_view.width
mines1 = len(self.random_view.grid.give_mines_locations())
self.difficulty.medium()
self.game_status = GameStatus()
self.random_view = ViewGrid(self.difficulty, self.game_status)
self.random_view.push_left_button(0, 0)
height2 = self.random_view.height
width2 = self.random_view.width
mines2 = len(self.random_view.grid.give_mines_locations())
self.difficulty.hard()
self.game_status = GameStatus()
self.random_view = ViewGrid(self.difficulty, self.game_status)
self.random_view.push_left_button(0, 0)
height3 = self.random_view.height
width3 = self.random_view.width
mines3 = len(self.random_view.grid.give_mines_locations())
results = (width1, height1, mines1, width2, height2, mines2, width3,
height3, mines3)
self.assertEqual(results, (9, 9, 10, 16, 16, 40, 30, 16, 99))
def __init__(self):
pygame.init()
self.settings = Settings()
self.gamestatus = GameStatus()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.screen_rect = self.screen.get_rect()
pygame.display.set_caption("WBPong")
self.main_menu = Menu(self, "Play", "Exit")
self.pause_menu = Menu(self, "Resume", "New game", "Exit")
self.pause_button = Button(self, 24, 50, 25, "Pause")
self.left_paddle = Paddle(self, 1)
self.right_paddle = Paddle(self, 2)
self.ball = Ball(self)
self.scores = Score(self)
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init()
pygame.mixer.init()
screen = pygame.display.set_mode((1000, 600))
pygame.display.set_caption("Plants VS Zombie")
ai_setting = Setting()
#声音的设置
soundwav = pygame.mixer.Sound("boom.wav")
pygame.mixer.music.load("first.wav")
pygame.mixer.music.play(-1)
#创建play按钮
play_button = Button(ai_setting, screen, "Play", 400)
exit_button = Button(ai_setting, screen, "Exit", 500)
#创建一个射手,一个豌豆编组，一个僵尸编组和一个僵尸Boss编组
peashooter = Peashooter(ai_setting, screen)
peas = Group()
zombies = Group()
bossGroup = Group()
#创建一个用于存储游戏统计信息的实例，并创建记分牌
status = GameStatus(ai_setting)
scoreboard = Scoreboard(ai_setting, screen, status)
#开始游戏的主循环
while True:
gf.check_events(ai_setting, screen, status, scoreboard, play_button,
exit_button, peashooter, zombies, peas)
if status.game_active:
peashooter.update()
gf.update_peas(ai_setting, screen, status, scoreboard, soundwav,
peashooter, zombies, bossGroup, peas)
gf.update_zombies(ai_setting, status, screen, scoreboard,
peashooter, zombies, bossGroup, peas)
gf.update_bossGroup(ai_setting, status, screen, scoreboard,
peashooter, zombies, bossGroup, peas)
gf.update_screen(ai_setting, screen, status, scoreboard, peashooter,
zombies, bossGroup, peas, play_button, exit_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")
play_button = Button(ai_settings, screen, "Play")
# 创建一艘飞船
ship = Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
# 创建一个用于存储游戏统计信息的实例
status = GameStatus(ai_settings)
sb = Scoreboard(ai_settings, screen, status)
pygame.mixer.music.load("sounds/background.wav")
pygame.mixer.music.play(-1, 0.0)
#开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, status, play_button, ship, aliens,
bullets, sb)
if status.game_active:
ship.update()
# 删除已消失的子弹
gf.update_bullets(ai_settings, screen, ship, aliens, bullets,
status, sb)
gf.update_aliens(ai_settings, status, screen, ship, aliens,
bullets, sb)
#gf.dectet_fire(bullets, aliens)
gf.update_screen(ai_settings, screen, status, ship, aliens, bullets,
play_button, sb)
def __init__(self):
'''初始化游戏并创建游戏资源'''
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption('外星人入侵')
# 设置游戏背景颜色
self.bg_color = self.settings.bg_color
# 实例化飞船，并将主程序作为对象传入
self.ship = Ship(self)
# 实例化子弹编组
self.bullets = pygame.sprite.Group()
# 实例化外星人编组
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.status = GameStatus(self)
self.gameover = Gameover(self)
def main():
#----------
#init初始化所有模块，并检查
pygame.init()
#----------
#从配置文件中拿参数
bj_settings = Settings()
#----------
#设置屏幕大小,flags:扩展选项
screen = pygame.display.set_mode(
(bj_settings.screen_width, bj_settings.screen_height),
pygame.RESIZABLE, 32)
#设置游戏主题
pygame.display.set_caption('Alien Invasion')
#设置窗口图标
icon = pygame.image.load('image/ship.bmp')
pygame.display.set_icon(icon)
status = GameStatus(bj_settings)
sc = Scoreboard(bj_settings, screen, status)
#-----------
#创建一个船的对象，调用船的位置方法
ship = Ship(bj_settings, screen)
# alien = Alien(screen)
#-----------
bullets = Group()
aliens = Group()
game_functions.create_aliens(screen, bj_settings, aliens, ship)
play_button = Button(bj_settings, screen, 'PLAY')
while True:
game_functions.check_events(screen, bj_settings, ship, bullets, status,
play_button, aliens, sc)
game_functions.update_screen(status, screen, bj_settings, ship, aliens,
bullets, play_button, sc)
if status.game_active:
ship.continue_update()
# bullets.update()
# game_functions.update_bullets(bullets)
game_functions.update_screen(status, screen, bj_settings, ship,
aliens, bullets, play_button, sc)
def test_if_the_flag_in_a_wrong_places_gives_right_answer(self):
self.random_view.push_left_button(0, 0)
mine_locations = self.random_view.grid.give_mines_locations()
coord_y = None
coord_x = None
not_found = True
while not_found:
for i in range(self.random_view.height):
for j in range(self.random_view.width):
if not_found and (i, j) not in mine_locations:
if self.random_view.coordinates(i, j) == " ":
self.random_view.push_right_button(i, j)
coord_y = i
coord_x = j
not_found = False
if not_found:
self.game_status = GameStatus()
self.random_view = ViewGrid(self.difficulty, self.game_status)
self.random_view.push_left_button(mine_locations[0][0],
mine_locations[0][1])
result = self.random_view.coordinates(coord_y, coord_x)
self.assertEqual(result, "w")
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(ai_settings.caption)
play_button = Button(screen, 'PLAY')
status = GameStatus(ai_settings)
scoreboard = Scroeboard(screen, ai_settings, status)
ship = Ship(screen, ai_settings)
bullets = Group()
aliens = Group()
# 创建外星人集群
gf.create_fleet(screen, ai_settings, aliens, ship)
# 开始游戏主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ship, bullets, screen, ai_settings, status,
play_button, aliens, scoreboard)
if status.game_active is True:
# 更新飞船
ship.update()
# 更新子弹
gf.update_bullets(bullets, aliens, screen, ai_settings, ship,
status, scoreboard)
# 更新外星人
gf.update_aliens(aliens, ai_settings, ship, status, bullets,
screen, scoreboard)
# 更新屏幕
gf.update_screen(ai_settings, screen, ship, bullets, aliens,
play_button, status, scoreboard)
def run_game():
pygame.init()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption('外星飞船大战')
pygame.mouse.set_visible(True)
play_button = Button(screen, 'Play')
my_ship = Ship(screen)
status = GameStatus()
sb = ScoreBoard(screen, status)
aliens = Group()
gf.create_fleet(screen, my_ship, aliens)
while 1:
gf.deal_events(my_ship, screen, aliens, status, play_button)
if status.game_active:
gf.update_bullets(screen, my_ship, aliens, status, sb)
my_ship.update()
gf.update_aliens(screen, my_ship, aliens, status)
gf.update_screen(screen, my_ship, aliens, status, sb, play_button)
from pygame.sprite import Group
from pygame.locals import *
from enemy import BigEnemy
# initialization of pygame
pygame.init()
# initialization of audios
pygame.mixer.init()
# build an instance of class Settings()
settings = Settings()
# acquire an screen object
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height), 0, 32)
# build an instance of class GameStatus()
gameStatus = GameStatus()
# build an instance of class GameMap()
gameMap1 = GameMap(0, 0, settings, screen)
gameMap2 = GameMap(0, -settings.screen_height, settings, screen)
# buip an ship
ship = Ship(settings, screen)
# build a scoreboard
scoreBoard = ScoreBoard(settings, screen, gameStatus)
# build an bullet
bullets = Group()
bulletAmmos = Group()
bombAmmos = Group()
small_enemies = Group()
middle_enemies = Group()
#big_enemies = Group()
boss = Group()
def __init__(self, settings: dict): self.game_status = GameStatus(settings)
pressed_keys.add(key)
def key_release(key, modificators):
'''Processes key release'''
pressed_keys.discard(key)
# batch for graphics
batch = pyglet.graphics.Batch()
batch_status = pyglet.graphics.Batch()
batch_bkg = pyglet.graphics.Batch()
batch_effects = pyglet.graphics.Batch()
# game state
game_status = GameStatus(batch_status, SHIP_IMAGE_INDEX, WINDOW_WIDTH,
WINDOW_HEIGHT)
game_status.draw_lifes()
#game_status.draw()
# space
space = Space(WINDOW_WIDTH, WINDOW_HEIGHT, batch, batch_effects, game_status,
SHIP_IMAGE_INDEX)
space.create_objects()
# window
window = pyglet.window.Window(space.width, space.height, caption='ASTEROIDS')
window.push_handlers(on_draw=draw,
on_key_press=key_press,
on_key_release=key_release)
background = pyglet.image.load(choice(BACKGROUNDS))
sprite = pyglet.sprite.Sprite(background, batch=batch_bkg)
class AlienInvasion:
def __init__(self):
pygame.init()
self.my_setting = Settings()
self.screen = pygame.display.set_mode(
(self.my_setting.screen_width, self.my_setting.screen_height))
pygame.display.set_caption('Alien Invasion')
self.color = self.my_setting.bg_color
'''放在初始化完成下面'''
self.ship = Ship(self)
'''子弹'''
self.bullets = pygame.sprite.Group()
self.is_bulleting = False
'''外星人'''
self.aliens = pygame.sprite.Group()
self._build_aliens()
'''游戏状态'''
self.status = GameStatus(self)
'''play按钮'''
self.play_button = Button(self, 'Play')
'''分数按钮'''
self.sb = ScoreBoard(self)
def run_game(self):
self._auto_fire()
while True:
self._check_event()
if self.status.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
'''--------------------------'''
def _build_aliens(self):
alien_sample = Alien(self)
alien_width = alien_sample.rect.width
alien_height = alien_sample.rect.height
'''可用宽度'''
available_space_x = self.screen.get_rect().width - 2 * alien_width
available_number_x = available_space_x // (2 * alien_width)
'''可用高度'''
available_space_y = self.screen.get_rect().height - 3 * alien_width
available_number_y = available_space_y // (2 * alien_height)
for num_y in range(available_number_y):
for num_x in range(available_number_x):
alien = self._create_alien(num_x, num_y)
self.aliens.add(alien)
def _create_alien(self, num_x, num_y):
alien = Alien(self)
alien.x = alien.rect.width + num_x * (2 * alien.rect.width)
alien.rect.x = alien.x
alien.y = alien.rect.height + num_y * (2 * alien.rect.width)
alien.rect.y = alien.y
return alien
def _update_bullets(self):
self.bullets.update()
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collide()
def _check_bullet_alien_collide(self):
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
'''增加得分'''
if collisions:
for aliens in collisions.values():
for alien in aliens:
self.status.score += self.my_setting.per_alien_score
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
self.bullets.empty()
self.my_setting._increase_speed()
self.status.level += 1
self.sb.prep_level()
self._build_aliens()
def _update_aliens(self):
self._check_alien_edge()
self.aliens.update()
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
self._check_alien_bottom()
def _ship_hit(self):
self._reset_scene_status()
self.status.minus_ship()
self.sb.prep_ships()
sleep(1)
def _check_alien_bottom(self):
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self._ship_hit()
break
def _check_alien_edge(self):
for alien in self.aliens.sprites():
if alien.check_edge():
self._change_alien_direction(alien)
break
def _change_alien_direction(self, alien):
self.my_setting.alien_direction = self.my_setting.alien_direction * (
-1)
for alien in self.aliens.sprites():
alien.y += self.my_setting.alien_spped_y
alien.rect.y = alien.y
def _check_event(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.status.save_high_score()
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_key_down(event)
elif event.type == pygame.KEYUP:
self._check_key_up(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_mouse_down(mouse_pos)
def _check_key_down(self, event):
if event.key == pygame.K_RIGHT:
self.ship.right_moving = True
elif event.key == pygame.K_LEFT:
self.ship.left_moving = True
elif event.key == pygame.K_q:
self.status.save_high_score()
sys.exit()
elif event.key == pygame.K_SPACE:
# self._fire_bullet()
self.fire_job.resume()
elif event.key == pygame.K_p:
self._start_game()
def _check_key_up(self, event):
if event.key == pygame.K_RIGHT:
self.ship.right_moving = False
elif event.key == pygame.K_LEFT:
self.ship.left_moving = False
elif event.key == pygame.K_SPACE:
# self._fire_bullet()
self.fire_job.pause()
def _check_mouse_down(self, pos):
if self.play_button.rect.collidepoint(pos):
self._start_game()
def _start_game(self):
if not self.status.game_active:
self.status.reset()
self.sb.prep_score()
self.sb.prep_high_score()
self.sb.prep_level()
self.sb.prep_ships()
self.status.game_active = True
self._reset_scene_status()
self.my_setting._init_dynamic_setting()
pygame.mouse.set_visible(False)
def _reset_scene_status(self):
self.aliens.empty()
self.bullets.empty()
self._build_aliens()
self.ship.center_place()
def _auto_fire(self):
scheduler = BackgroundScheduler()
self.fire_job = scheduler.add_job(self._fire_bullet,
'interval',
seconds=0.1)
scheduler.start()
self.fire_job.pause()
def _update_screen(self):
self.screen.fill(self.color)
self.ship.blitme()
'''绘制子弹'''
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
if not self.status.game_active:
self.play_button.draw_button()
self.sb.draw_score()
pygame.display.flip()
def _fire_bullet(self):
if self.status.game_active:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
