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 now!")
stats = GameStats(ai_settings)
scoreboard = 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, play_button, ship, aliens,
bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, scoreboard, ship,
aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, stats, scoreboard, 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 War")
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()
f.create_fleet(ai_settings, screen, ship, aliens)
# Назначение цвета фона
bg_color = (100, 100, 100)
alien = Alien(ai_settings, screen)
while True:
f.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
f.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
f.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets)
f.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))
ship = Ship(screen, ai_settings)
pygame.display.set_caption("alien vision")
play_button = Button(screen, ai_settings, "play")
stats = GameStats(ai_settings)
sb = ScoreBoard(screen, ai_settings, stats)
bullets = Group()
# alien=Alien(ai_settings, screen)
aliens = Group()
gf.create_fleet(ai_settings, screen, aliens, ship)
while True:
gf.check_events(ai_settings, ship, screen, bullets, stats, play_button,
aliens, sb) # bullets
if stats.game_active:
ship.update()
# bullets.update()
gf.update_bullet(aliens, bullets, ai_settings, screen, ship, stats,
sb)
gf.update_aliens(ship, aliens, ai_settings, stats, screen, bullets,
sb)
gf.screen_update(ship, screen, ai_settings, bullets, aliens,
play_button, stats, sb) # 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")
# 创建play按钮
play_button = Button(ai_settings, screen, "Play")
# 用于存储统计信息的实例
stats = GameStats(ai_settings)
# 创建飞船
ship = Ship(ai_settings, screen)
# 创建记分牌
sb = ScoreBoard(ai_settings, screen, stats)
# 创建存储子弹的编组
bullets = Group()
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
"""开始游戏"""
while True:
# 监听键盘和鼠标事件
gf.check_events(ai_settings, stats, screen, ship, aliens, bullets, play_button, sb)
if stats.game_active:
ship.update()
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets, sb)
gf.update_bullets(ai_settings, stats, screen, ship, aliens, bullets, sb)
gf.update_screen(ai_settings, stats, screen, ship, aliens, bullets, play_button, sb)
def run_game():
pygame.init()
ai_setting = Setting() # 导入设置
screen = pygame.display.set_mode(
(ai_setting.screen_wide, ai_setting.screen_height))
pygame.display.set_caption("Alien Invasion") # 设置屏幕宽度、高度，标题
ship = Ship(ai_setting, screen)
bullets = Group()
bullets_a = Group()
aliens = Group()
gf.creat_fleet(ai_setting, screen, aliens, ship)
stats = GameStats(ai_setting)
sb = ScoreBoard(ai_setting, screen, stats)
play_button = Button(ai_setting, screen, u"PLAY")
while True:
gf.check_event(ai_setting, sb, screen, stats, play_button, ship,
aliens, bullets, bullets_a)
if stats.game_active:
ship.update()
gf.update_bullets(ai_setting, screen, stats, sb, ship, aliens,
bullets, bullets_a)
gf.update_aliens(ai_setting, stats, sb, screen, ship, aliens,
bullets, bullets_a)
gf.update_screen(ai_setting, screen, stats, sb, ship, aliens, bullets,
bullets_a, play_button)
def run_game():
# 初始化pygame、设置和屏幕对象
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height)) #窗口大小1200*800像素
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() #创建一个用于存储外星人的编组
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()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets) #更新子弹位置
gf.update_aliens(ai_settings, stats, sb, screen, ship, aliens,
bullets) #更新外星人位置
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button) #更新屏幕
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("外星人入侵！ Author: Cheng_CN")
#创建按钮
play_button = Button(ai_settings, screen, u"开始游戏")
#创建存储游戏统计信息的实例，并创建计分牌
stats = GameStats(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats)
#创建一艘飞船、一个子弹编组和一个外星人编组
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
ships = Group()
#创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
gf.ship_lefts(ai_settings, stats, screen, ships)
#开始游戏主循环
while True:
gf.check_events(ai_settings, screen, stats, play_button, ship, ships, aliens, bullets)
if stats.game_active:
ship.update()
bullets.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, sb, ship, ships, aliens, bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, ships, aliens, bullets,
play_button)
def run_game():
'''初始化游戏并创建一个对象'''
pygame.init()
ai_setting = Settings()
screen = pygame.display.set_mode((ai_setting.width, ai_setting.height))
pygame.display.set_caption('Alien Invasion')
stats = GameStats(ai_setting)
sb = ScoreBoard(ai_setting, screen, stats)
play_button = Button(ai_setting, screen, 'Play')
ship = Ship(ai_setting, screen)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_setting, screen, aliens, ship)
while True:
gf.check_events(ai_setting, screen, aliens, ship, bullets, play_button, stats, sb)
if stats.game_active:
ship.update()
gf.update_bullets(ai_setting, screen, bullets, aliens, ship, stats, sb)
gf.update_aliens(ai_setting, stats, screen, aliens, ship, bullets, sb)
gf.update_screen(ai_setting, screen, ship, aliens, bullets, stats, play_button, sb)
def run_game():
"""初始化pygame、设置和屏幕"""
pygame.init()
gui_setting = Settings()
screen = pygame.display.set_mode(
(gui_setting.screen_width, gui_setting.screen_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(gui_setting, screen, "PLAY")
stats = GameStats(gui_setting)
sb = ScoreBoard(gui_setting, screen, stats)
# 创建飞船、子弹、外星人
ship = Ship(screen, gui_setting)
bullets = Group()
aliens = Group()
# 创建一群外星人
gf.creat_aliens(gui_setting, screen, aliens)
# 开始游戏主循环
while True:
gf.check_events(gui_setting, screen, ship, bullets, stats, play_button,
aliens, sb)
if stats.game_active == True:
ship.update()
gf.update_bullets(gui_setting, screen, bullets, aliens, sb, stats)
gf.update_alien(gui_setting, stats, screen, ship, aliens, bullets,
sb)
gf.update_screen(gui_setting.bg_color, gui_setting, screen, stats,
ship, bullets, aliens, play_button, sb)
def run_game():
pygame.init()
ai_settings = Settings()
window = pygame.display.set_mode(
(ai_settings.window_width, ai_settings.window_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(ai_settings, window, "Play")
stats = GameStats(ai_settings)
ship = Ship(ai_settings, window)
sb = ScoreBoard(ai_settings, window, stats)
bullets = Group()
aliens = Group()
gf.create_fleets(ai_settings, window, ship, aliens)
while True:
gf.check_events(ai_settings, window, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, window, stats, sb, ship, bullets,
aliens)
gf.update_aliens(ai_settings, window, stats, sb, ship, aliens,
bullets)
gf.update_screen(ai_settings, stats, sb, window, aliens, ship, bullets,
play_button)
def run_game():
# Инициализирует pygame, settings и объект экрана
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")
# Создание экземпляра GameStats и ScoreBoard
stats = GameStats(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats)
# Создаем корабль
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, stats, sb, ship, aliens, bullets,
play_button)
if stats.game_active:
ship.update()
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))
stats = GameStats(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats) #初始化设置和统计信息
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)
#游戏主循环
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active == True:
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets)
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
def run_game():
ai_setting = Setting()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption('Alien Invasi on')
ship = Ship(screen)
bullets = Group()
aliens = Group()
gf.create_alien_fleet(ai_setting, aliens, screen)
stats = GameStats(ai_setting)
play_botton = Botton(screen, 'Play')
sb = ScoreBoard(screen, ai_setting, stats)
while True:
screen.fill(ai_setting.bg_color)
gf.check_events(ship, bullets, screen, ai_setting, play_botton, stats,
aliens, sb)
if stats.game_active:
ship.ship_update(ai_setting)
gf.update_aliens(aliens, ai_setting, ship, stats, bullets, screen,
sb)
gf.update_bullets(bullets, aliens, screen, ai_setting, stats, sb)
gf.screen_update(screen, ai_setting, ship, bullets, aliens,
play_botton, stats, sb)
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")
# 创建存储游戏统计信息的实例，并创建记分牌
stats = GameStats(ai_setting)
sb = ScoreBoard(ai_setting, screen, stats)
# 创建一艘飞船
ship = Ship(ai_setting, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
# 创建一个外星人
aliens = Group()
# 创建外星人群
gf.create_fleet(ai_setting, screen, ship, aliens)
# 开始游戏的主循环
while True:
gf.check_events(ai_setting, screen, stats, sb, play_button, ship, aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_setting, screen, stats, sb, ship, aliens, bullets)
gf.update_aliens(ai_setting, stats, sb, screen, ship, aliens, bullets)
gf.update_screen(ai_setting, stats, sb, screen, ship, aliens, bullets, play_button)
def new_game(self):
"""Start a new game of Feed-Me.
Resets all game-level parameters, and starts a new round.
"""
self.scoreboard = ScoreBoard(self.screen)
self.icons = []
for instance in self.scoreboard.items.sprites():
if instance.prefix == "Score: ":
self.score = instance
elif instance.prefix == "Level: ":
self.level = instance
elif instance.prefix == 'icon':
self.icons.append(instance)
elif instance.prefix == 'progress':
self.progress_bar = instance
elif instance.prefix == 'p_hero':
self.p_hero = instance
elif instance.prefix == 'goalbar':
self.goalbar = instance
self.running = self.splashscreen.draw()
self.distance = self.hero.sprite.rect.y - self.giant.sprite.rect.y
# self.plates = pygame.sprite.Group()
self.new_level()
def run_game():
#初始化游戏并创建一个屏幕对象
pygame.init()
#生成游戏场景对象，screen对象，飞船，外星人，子弹，游戏状态，按钮，记分牌
game_setting = Setting()
screen = pygame.display.set_mode(
(game_setting.screen_width, game_setting.screen_height))
pygame.display.set_caption("Alien Invsion")
bullets = []
ship = Ship(screen)
play_button = Button(screen, 'Play')
stats = GameStats(game_setting)
score_board = ScoreBoard(game_setting, screen, stats)
aliens = []
gf.create_alien_feet(game_setting, screen, ship, aliens)
#开始游戏的主循环
while True:
#获取事件响应
gf.check_event(game_setting, screen, ship, bullets, stats, play_button,
aliens)
if stats.game_active:
ship.update()
gf.update_bullet(game_setting, screen, ship, bullets, aliens,
score_board, stats)
gf.update_alien(game_setting, screen, bullets, aliens, ship, stats)
gf.update_screen(game_setting, screen, ship, bullets, aliens,
play_button, stats, score_board)
def run():
settings = Settings()
pygame.init()
screen = pygame.display.set_mode((settings.width, settings.height))
pygame.display.set_caption('alien invasion')
''' Создание экземпляров'''
ship = Ship(settings, screen)
alien = Alien(settings , screen)
''' Группы для обработки'''
bullets = Group()
aliens = Group()
''' Создание флота пришельцев'''
game_functions.create_fleet(settings , screen ,ship, aliens)
''' Создание класса для ведения статичтики'''
stats = GameStats(settings)
score_board = ScoreBoard(settings, screen, stats, )
'''Создание кнопки PLAY'''
play_button = Button(settings , screen, 'PLAY')
while True:
game_functions.check_events(settings, screen, stats, score_board, play_button, ship, aliens, bullets)
if stats.game_active:
# если корабли еще остались у игрока
ship.update_ship()
game_functions.update_bullets(settings, screen, stats, score_board, ship, aliens, bullets)
game_functions.update_aliens(stats, screen, bullets, score_board, settings, aliens, ship)
game_functions.update_screen(score_board, settings, screen, ship, aliens, stats, bullets, play_button) # здесь settings screen ship и bullets
def run_game():
# Initialize the game
pygame.init()
# Configure the game
setting = Settings()
screen = pygame.display.set_mode(setting.get_screen_size())
pygame.display.set_caption('Alien Invasion')
# Create button
play_button = Button(setting, screen, 'Play')
# Create a ship
ship = Ship(screen)
# Create game stats instance
game_stats = GameStats(setting)
# Create score board
sb = ScoreBoard(screen, setting, game_stats)
# Create bullets
bullets = Group()
# Create aliens
aliens = Group()
# Create life
lifes = Group()
while True:
# 监听
gf.check_events(setting, screen, ship, bullets, game_stats, play_button, aliens, lifes)
if game_stats.game_active:
gf.update_aliens(aliens, setting, ship, game_stats, bullets, screen, lifes)
gf.update_bullets(bullets, aliens, screen, setting, game_stats, sb)
gf.update_screen(setting, screen, ship, bullets, aliens, play_button, game_stats, sb, lifes)
def run_game():
# 初始化pygame，设置和屏幕对象
pygame.init()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
pygame.display.set_caption('Alien Invasion')
play_button = Button(ai_setting, screen, 'Play')
ship = Ship(ai_setting, screen)
bullets = Group() # pygame.sprite中的Group类相当于一个编组列表
aliens = Group()
stats = GameStats(ai_setting)
sb = ScoreBoard(ai_setting, screen, stats)
# 创建外星人群, 不能放在下面的循环中创建，只要在循环前创建一批外星人就够了
gf.create_fleets(ai_setting, screen, ship, aliens)
# 开始游戏主循环
while True:
# 监控事件
gf.check_events(ai_setting, screen, stats, sb, play_button, ship,
aliens, bullets)
# 检查激活状态，激活则继续执行下面的代码
if stats.game_active:
ship.update()
# 直接调用game_function中的update_bullets函数
gf.update_bullets(ai_setting, screen, stats, sb, ship, aliens,
bullets)
# 更新外星人的移动位置
gf.update_aliens(ai_setting, screen, stats, sb, ship, aliens,
bullets)
# 每次循环都会重绘屏幕
gf.update_screen(ai_setting, screen, stats, sb, ship, aliens, bullets,
play_button)
def run():
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()
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()
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)
class ScoreBoardTest(TestCase):
"""
Class to test the Score Board class
"""
def setUp(self):
self.sboard = ScoreBoard()
self.sboard.is_exist = 1
def test_score_update(self):
"""
Tests score update
"""
prev_score = self.sboard.score
self.sboard.score_update("enemy")
self.assertEqual(prev_score + 10, self.sboard.score)
def test_score_update1(self):
"""
Tests score update
"""
prev_score = self.sboard.score
self.sboard.score_update("coin")
self.assertEqual(prev_score + 5, self.sboard.score)
def test_score_update2(self):
"""
Tests score update
"""
prev_score = self.sboard.score
self.sboard.score_update("time")
self.assertEqual(prev_score + 1, self.sboard.score)
def test_score_update3(self):
"""
Tests score update
"""
prev_score = self.sboard.score
self.sboard.score_update("bossenemy")
self.assertEqual(prev_score + 100, self.sboard.score)
def test_life_update(self):
"""
Tests life update
"""
prev_life = self.sboard.life
self.sboard.life_update()
self.assertEqual(prev_life - 1, self.sboard.life)
def run_game():
"""游戏处理框架"""
#初始化所有导入的pygame模块
pygame.init()
#使用默认配置
ai_settings = Settings()
#初始化准备显示的窗口
#screen = pygame.display.set_mode(
# (ai_settings.screen_width,
# ai_settings.screen_height))
#可以通过参数启动全屏窗口
screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
#设置窗口标题
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)
#用来保存所有子弹的Group
bullets = Group()
#创建一群外星人
aliens = Group()
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()
#更新子弹位置，同时删除无用的子弹
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)
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init() # init of pygame which allows us to use various commands of pygame
self.settings = Settings() # default settings are inside Settings class
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) # width and height
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion") # title
self.stats = GameStats(self)
self.sb = ScoreBoard(self)
self.ship = Ship(self) # passing current instance of AlienInvasion class to Ship class
self.bullets = pygame.sprite.Group() # creates empty group for bullets
self.aliens = pygame.sprite.Group() # creates empty group for aliens
self._create_fleet()
self.easy_button = Button(self, 'Easy', (0, 255, 0))
self.medium_button = Button(self, 'Medium', (255, 255, 0))
self.hard_button = Button(self, 'Hard', (255, 0, 0))
def __init__(self, width_s, height_s):
super(Mario,
self).__init__(int(3 * height_s / 4) - 2, int(width_s / 2))
self.structure = np.matrix([['o', 'o'], [']', '[']])
self._jump = 0
self.on_ground = True
self._type = "player"
self.scoreboard = ScoreBoard()
def run_game():
#Initialize game and create a screen object
pygame.init()
ai_settings = Settings()
#Make a group that stores bullet
#Make an alien
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
#Create an instance to store game statistics and create a scoreboard
stats = GameStats(ai_settings)
sb = ScoreBoard(ai_settings, screen, stats)
#set the background color.
bg_color = (230, 230, 230)
#Start the main cloop for the game
#Make a Ship
ship = Ship(ai_settings, screen)
alien = Alien(ai_settings, screen)
bullets = Group()
aliens = Group()
#Make the play button
play_button = Button(ai_settings, screen, "Play")
#Create a fleet of aliens
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()
bullets.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, screen, stats, sb, 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))
#Watch for keyboard and mouse events.
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
#mAKE THE MOST RECENTLY DRAWN SCREEN VISIBLE
#redraw the screen during each pass through the VISIBLE
screen.fill(ai_settings.bg_color)
ship.blitme()
pygame.display.flip()
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
def __init__(self, display):
self.display = display
self.animations_mgr = AnimationController()
self.surface = pygame.Surface(DISPLAY_SIZE, pygame.SRCALPHA, 32)
self.field = Field(self.surface)
self.scoreboard = ScoreBoard(self.surface, SCOREBOARD_POS)
self.pause_menu = MenuPause(self.display, self)
self.menu_pos = ((self.field.rect.width - self.pause_menu.width) / 2,
(self.field.rect.height - self.pause_menu.height) / 2)
self.menu_end = None
self.score = (0, 0)
self.sprites = pygame.sprite.RenderPlain()
self.sliders = []
self.goals = {}
self.balls = []
self.state = 'need_wait_put_ball'
self.pressing_escape = False
self.present()
def __init__(self):
self.system = platform.system()
pygame.init()
pygame.display.set_caption('Flappy Bird')
self.FPS = 55
self.SCREEN_WIDTH = 1000
self.SCREEN_HEIGHT = 563
self.screen = pygame.display.set_mode((self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
self.sliding_background = SlidingBackground(self.screen)
if self.system == 'Linux':
self.flappy_bird_title = Title(self.screen, r'images/title2.0.png', 466, 137, 50)
else:
self.flappy_bird_title = Title(self.screen, r'images\title2.0.png', 466, 137, 50)
if self.system == 'Linux':
self.game_over_title = Title(self.screen, r'images/game_over2.0.png', 383, 90, 50)
else:
self.game_over_title = Title(self.screen, r'images\game_over2.0.png', 383, 90, 50)
if self.system == 'Linux':
self.start_image_button = ImageButton(self.screen, r'images/start_button3.0.png', 183, 109, 400)
else:
self.start_image_button = ImageButton(self.screen, r'images\start_button3.0.png', 183, 109, 400)
self.scoreboard = ScoreBoard(self.screen)
self.retry_button = Button(self.screen, 425, 'Retry')
self.bird = Bird(self.screen)
# True until reset in pressed
self.game_active = False
# True until obstacle was hit
self.game_lost = False
self.score = 0
self.create_best_score_file()
self.get_best_score()
def execute(self):
self.__load_instructions()
self.reg_pc = 0
fetch_cycle = self.icache.get_from_cache(self.reg_pc)
clk_cnt = 1
print("total instructions: ", len(self.instructions))
#import sys
# sys.exit(0)
self.scoreboards.append(
ScoreBoard(clk_cnt, fetch_cycle, self.instructions[self.reg_pc],
self.instructions, self.cpu, self.clock_mgr,
self.memory_bus, self.dcache))
while self.reg_pc < len(self.instructions) - 1:
print("*** curr_pc: ", self.reg_pc)
flag = False
for j in range(len(self.scoreboards)):
temp = self.reg_pc
self.reg_pc = self.scoreboards[j].update(
clk_cnt, self.reg_pc + 1, j + 1, flag) - 1
if self.reg_pc != temp:
flag = True
if self.scoreboards[-1].is_fetch_free:
self.reg_pc += 1
fetch_cycle = self.icache.get_from_cache(self.reg_pc)
self.scoreboards.append(
ScoreBoard(clk_cnt, fetch_cycle,
self.instructions[self.reg_pc],
self.instructions, self.cpu, self.clock_mgr,
self.memory_bus, self.dcache))
clk_cnt += 1
self.clock_mgr.increament_clock()
'''if self.clock_mgr.get_clock() == 129:
print("scoreboard iss: ",self.scoreboards)
break
'''
for _ in range(100):
for j in range(len(self.scoreboards)):
self.scoreboards[j].update(clk_cnt, self.reg_pc, j + 1, False)
clk_cnt += 1
self.clock_mgr.increament_clock()
print("Writing results after clok: ", clk_cnt)
self.write_result_file(self.scoreboards, self.dcache, self.icache,
self.res_file)
def __init__(self):
"""Initialize the game , and create game resources"""
pygame.init()
self.setting = Setting()
self.bullets = pygame.sprite.Group(
) # use for collecting similar type of object
self.screen = pygame.display.set_mode(
(0, 0), pygame.FULLSCREEN
) # 0 width and 0 length expresses the full screen
self.setting.screen_width = self.screen.get_rect().width
self.setting.screen_height = self.screen.get_rect().height
# pygame.display.set_caption("Alien Invasion")
self.ship = Ship(self)
self.enemy = pygame.sprite.Group()
self.stats = GameStats(self)
self.score_board = ScoreBoard(self) #create a score board
self._create_fleet()
# as we need only one button then we need to call it once
self.play_button = Button(self, "Play")
def Main():
global scoreboard
scores = dict()
maxCell = dict()
options = browser_options.BrowserFinderOptions()
parser = options.CreateParser('telemetry_perf_test.py')
options, _ = parser.parse_args(['--browser=system'])
browser_to_create = browser_finder.FindBrowser(options)
assert browser_to_create
with browser_to_create.Create() as b:
ai_list = enumerateAIs()
for ai in ai_list:
scores[ai[0]] = list()
maxCell[ai[0]] = 2
if HAS_SCOREBOARD:
scoreboard = ScoreBoard(b.tabs.New(), ITERATION)
for ai in ai_list:
scoreboard.addAI(ai[0])
waitStart(scoreboard.tab)
b.tabs[0].Activate()
for iteration in xrange(ITERATION):
for ai in ai_list:
try:
s, mc = play(b.tabs[0], ai)
except AIError, err:
s = err.score
mc = err.maxCell
logMsg("%s(%d): %s" % (ai[0], iteration + 1, err.msg))
if mc > maxCell[ai[0]]:
maxCell[ai[0]] = mc
scoreboard.setScore(ai[0], ITERATION + 1, mc)
scores[ai[0]].append(s)
scoreboard.setScore(ai[0], iteration, s)
if ITERATION > 2:
for ai in ai_list:
avg = ((sum(scores[ai[0]]) - max(scores[ai[0]]) - min(scores[ai[0]])) /
(ITERATION - 2))
scoreboard.setScore(ai[0], ITERATION, avg)
print "%s avg = %d\n" % (ai[0], avg)
if HAS_SCOREBOARD:
time.sleep(10000)
def __init__(self, parent=None, h=None, w=None, **configs):
super().__init__(parent, height=h, width=w, bd=0, **configs)
self.height = h
self.width = w
self.pack(expand=YES, fill=BOTH)
self.score_board = ScoreBoard()
self.draw_elements()
self.dr_l = [(4, 4), (4, -4), (5, 3), (5, -3), (6, 2), (6, -2), (7, 1),
(7, -1)]
self.dr_r = [(-4, 4), (-4, -4), (-5, 3), (-5, -3), (-6, 2), (-6, -2),
(-7, 1), (-7, -1)]
self.upf = False
self.downf = False
self.focus_set()
self.bind('<KeyPress>', self.start)
self.bind('<Up>', self.up_pressed)
self.bind('<KeyRelease-Up>', self.up_released)
self.bind('<Down>', self.down_pressed)
self.bind('<KeyRelease-Down>', self.down_released)
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
self.bg_color = self.settings.bg_color
pygame.display.set_caption("Alien Invasion")
self.stats = GameStats(self)
self.sb = ScoreBoard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.button = Button(self, "Gra")
def __init__(self):
pygame.mixer.init(11025,-16,2,4096)
pygame.mixer.set_num_channels(3)
pygame.init()
pygame.display.set_caption(WINDOW_TITLE)
self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
self.screen_width, self.screen_height = self.screen.get_size()
self.make_background()
self.scoreboard = ScoreBoard(self.screen)
self.splashscreen = SplashScreen()
self.hero = pygame.sprite.GroupSingle(Hero(self.background))
self.giant = pygame.sprite.GroupSingle(Giant(self.background))
self.plates = pygame.sprite.Group()
self.foods = pygame.sprite.Group()
#music
self.bounce = pygame.mixer.Sound('sounds/bounce.ogg')
self.chew = pygame.mixer.Sound('sounds/eating.wav')
# self.die = pygame.mixer.Sound('sounds/die.ogg')
# self.bsound = pygame.mixer.Sound('sounds/bsound.ogg')
# # #music
# self.bsound.set_volume(0.2)
# self.bsound.play(loops=100, maxtime=0, fade_ms=0)
# Use a clock to control frame rate
self.clock = pygame.time.Clock()
class PyGame(object):
"""Create a game of PyGame."""
def __init__(self):
pygame.mixer.init(11025,-16,2,4096)
pygame.mixer.set_num_channels(3)
pygame.init()
pygame.display.set_caption(WINDOW_TITLE)
self.screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
self.screen_width, self.screen_height = self.screen.get_size()
self.make_background()
self.scoreboard = ScoreBoard(self.screen)
self.splashscreen = SplashScreen()
self.hero = pygame.sprite.GroupSingle(Hero(self.background))
self.giant = pygame.sprite.GroupSingle(Giant(self.background))
self.plates = pygame.sprite.Group()
self.foods = pygame.sprite.Group()
#music
self.bounce = pygame.mixer.Sound('sounds/bounce.ogg')
self.chew = pygame.mixer.Sound('sounds/eating.wav')
# self.die = pygame.mixer.Sound('sounds/die.ogg')
# self.bsound = pygame.mixer.Sound('sounds/bsound.ogg')
# # #music
# self.bsound.set_volume(0.2)
# self.bsound.play(loops=100, maxtime=0, fade_ms=0)
# Use a clock to control frame rate
self.clock = pygame.time.Clock()
def new_game(self):
"""Start a new game of Feed-Me.
Resets all game-level parameters, and starts a new round.
"""
self.scoreboard = ScoreBoard(self.screen)
self.icons = []
for instance in self.scoreboard.items.sprites():
if instance.prefix == "Score: ":
self.score = instance
elif instance.prefix == "Level: ":
self.level = instance
elif instance.prefix == 'icon':
self.icons.append(instance)
elif instance.prefix == 'progress':
self.progress_bar = instance
elif instance.prefix == 'p_hero':
self.p_hero = instance
elif instance.prefix == 'goalbar':
self.goalbar = instance
self.running = self.splashscreen.draw()
self.distance = self.hero.sprite.rect.y - self.giant.sprite.rect.y
# self.plates = pygame.sprite.Group()
self.new_level()
def new_level(self):
"""Start a new round in a Breakout game.
Resets all round-level parameters, increments the round counter, and
puts the ball on the paddle.
"""
self.plates.empty()
self.foods.empty()
floor = pygame.sprite.Sprite()
floor.image = pygame.Surface((self.screen_width, 19)).convert_alpha()
floor.image.fill(pygame.Color('#008000'))
floor.rect = floor.image.get_rect(midbottom=(self.screen_width / 2, self.background_height + 10))
ceiling = pygame.sprite.Sprite()
ceiling.image = floor.image.copy()
ceiling.image.fill(pygame.Color('black'))
ceiling.rect = ceiling.image.get_rect(top=self.giant.sprite.rect.bottom)
self.plates.add(floor)
self.plates.add(ceiling)
food_probability = [5, 10, 20, 35, 50, 70]
# Plate generation
plate_xloc = self.screen_width / 2
plate_yloc = self.background_height - 50
while plate_yloc > self.giant.sprite.rect.bottom + 16:
xlocs = [9999999]
for i in range(random.randint(1, 3)):
approved = False
while not approved:
new_xloc = random.choice((random.randint(plate_xloc - 240, plate_xloc - 80),
random.randint(plate_xloc + 80, plate_xloc + 240)))
new_xloc = max(min(new_xloc, self.screen_width - 40), 40)
good = [j for j in xlocs if math.fabs(j - new_xloc) > 80]
if len(good) == len(xlocs):
approved = True
xlocs.append(new_xloc)
plate_xloc = new_xloc
plate = Plate(plate_xloc, plate_yloc)
self.plates.add(plate)
food_check = random.randint(1, 100)
for i in range(6):
if food_check < food_probability[i]:
self.foods.add(Food(i, plate))
break
plate_yloc -= random.randint(40, 120)
self.high_score = sum(food.points for food in self.foods.sprites())
self.level_score = 0
self.level.text += 1
self.goalbar.image = pygame.Surface((0, 0))
self.new_life()
def new_life(self):
self.scrollspeed = 0
self.vp = [0, -WINDOW_HEIGHT * 4]
self.hero.sprite.rect.midbottom = (self.background_width / 2, self.background_height)
def died(self, how):
self.splashscreen.message(how)
if len(self.icons) <= 1:
self.splashscreen.game_over()
self.new_game()
else:
self.scoreboard.items.remove(self.icons[0])
self.icons.remove(self.icons[0])
self.new_life()
def end_level(self):
if self.level_score > (self.high_score * .75):
self.splashscreen.message(2)
self.new_level()
else:
self.died(1)
def make_background(self):
self.background = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT * 5))
self.background_width, self.background_height = self.background.get_size()
self.background.fill(pygame.Color('skyblue'))
def play(self):
"""Start PyGame program.
"""
self.new_game()
while self.running:
self.clock.tick(FPS) # Max frames per second
# Event handling
for event in pygame.event.get():
if event.type == pygame.QUIT or (event.type == pygame.KEYDOWN and event.key == pygame.K_q):
self.running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT or event.key == pygame.K_d:
self.hero.sprite.xv = 6
if event.key == pygame.K_LEFT or event.key == pygame.K_a:
self.hero.sprite.xv = -6
if event.key == pygame.K_SPACE :
self.hero.sprite.jump = True
self.bounce.play(loops=0, maxtime=0, fade_ms=0)
# cheat code
# if event.key == pygame.K_UP:
# self.hero.sprite.yv = -20
if event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT or event.key == pygame.K_LEFT or event.key == pygame.K_d or event.key == pygame.K_a:
self.hero.sprite.xv = 0
# Is the hero colliding with a plate?
contact = pygame.sprite.spritecollide(self.hero.sprite, self.plates, False,
pygame.sprite.collide_mask)
self.hero.sprite.plate = contact
# If hero picks up food
collect = pygame.sprite.spritecollide(self.hero.sprite, self.foods, True,
pygame.sprite.collide_mask)
if collect:
for meal in collect:
self.score.text += meal.points
self.level_score += meal.points
self.goalbar.image = pygame.Surface((min(self.level_score * 100 / (self.high_score*.75), 100), 16))
self.goalbar.image.fill((255, 0, 0))
self.chew.play(loops=0, maxtime=1500, fade_ms=0)
self.chew.set_volume(1.0)
if self.background_height - self.hero.sprite.rect.centery > WINDOW_HEIGHT / 2:
self.scrollspeed = self.level.text + 1
# If you die
if self.hero.sprite.rect.centery - -self.vp[1] > self.screen_height:
self.died(0)
# Draw the scene
self.screen.fill((0, 0, 0))
self.background.fill(pygame.Color('#87CEFA'))
self.giant.draw(self.background)
self.plates.draw(self.background)
self.foods.draw(self.background)
self.hero.update()
self.hero.draw(self.background)
self.screen.blit(self.background, self.vp)
# Do the scoreboard
self.p_hero.rect.x = -12 + (((self.background_height - self.hero.sprite.rect.y) * self.progress_bar.rect.width) / self.distance)
self.scoreboard.update()
self.scoreboard.draw(self.screen)
pygame.display.flip()
self.vp[1] += self.scrollspeed
self.vp[1] = min(self.vp[1], 0)
if not self.vp[1]:
self.end_level()
curses.curs_set(0) # make the cursor invisible
curses.halfdelay(5) # wait only half a second between each getch
# Overload colors to make blocks
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_WHITE)
curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_GREEN)
curses.init_pair(3, curses.COLOR_BLUE, curses.COLOR_BLUE)
curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_YELLOW)
curses.init_pair(5, curses.COLOR_RED, curses.COLOR_RED)
try:
KEYS = KeyMap()
KEYS.load_from_file(CONFIG_FNAME)
GAME_BOARD = Board(STDSCR, [0, 0], [20, 20])
SCORE_BOARD = ScoreBoard(GAME_BOARD.status, 5, 25)
GAME_QUIT = False
LAST_GAME_STEP = time()
while not GAME_QUIT and not GAME_BOARD.game_over():
CURRENT_TIME = time()
if CURRENT_TIME - LAST_GAME_STEP > STEP_TIME:
GAME_BOARD.advance_block()
LAST_GAME_STEP = CURRENT_TIME
USR_INPUT = STDSCR.getch()
if USR_INPUT == KEYS.quit:
GAME_QUIT = True
elif USR_INPUT == KEYS.lshift:
GAME_BOARD.lshift_block()
elif USR_INPUT == KEYS.rshift:
def ioerror():
scoreboard = ScoreBoard('scoreboard/fixtures/test_file_incorrect.txt')
scoreboard.create()
class ScoreBoardTestCase(TestCase):
def setUp(self):
self.pathfile = 'scoreboard/fixtures/test_file.txt'
self.scoreboard = ScoreBoard(self.pathfile)
def test_check_score_response_C(self):
self.assertEqual(self.scoreboard.check_score_response('25', '21', 'C'), 46)
def test_check_score_response_I(self):
self.assertEqual(self.scoreboard.check_score_response('19', '46', 'I'), 66)
def test_check_score_response_R(self):
self.assertEqual(self.scoreboard.check_score_response('19', '11', 'R'), 11)
def test_check_quantity_problems_one(self):
self.assertEqual(self.scoreboard.check_quantity_problems(1, 1), 1)
def test_check_quantity_problems_two(self):
self.assertEqual(self.scoreboard.check_quantity_problems(1, 2), 2)
def test_check_team_in_result_true(self):
team = {
'team': '1',
'score': '66',
'problems': '2',
}
self.assertTrue(self.scoreboard.check_team_in_result('1', [team]), team)
def test_check_team_in_result_false(self):
self.assertFalse(self.scoreboard.check_team_in_result('1', []), False)
def test_team(self):
expect_result = {
'team': '1',
'problems': 2,
'score': 66
}
self.assertDictEqual(self.scoreboard.team('1', 2, 66, 'C'), expect_result)
def test_add_team(self):
result = []
result = self.scoreboard.add_team('1', '2', '10', 'I', result)
result = self.scoreboard.add_team('3', '1', '11', 'C', result)
result = self.scoreboard.add_team('1', '2', '19', 'R', result)
result = self.scoreboard.add_team('1', '2', '21', 'C', result)
result = self.scoreboard.add_team('1', '1', '25', 'C', result)
expect_result = [
{
'team': '1',
'problems': '2',
'score': 66
}, {
'team': '3',
'problems': '1',
'score': 11
}
]
self.assertListEqual(result, expect_result)
def test_sort_result(self):
result = [{
'team': '3',
'problems': '1',
'score': 11
}, {
'team': '1',
'problems': '2',
'score': 66
}
]
sorted_result = self.scoreboard.sort_result(result)
self.assertEqual(sorted_result[0]['team'], '1')
self.assertEqual(sorted_result[1]['team'], '3')
def test_create_file(self):
result = [
{
'team': '1',
'problems': '2',
'score': 66
}, {
'team': '3',
'problems': '1',
'score': 11
}
]
self.scoreboard.create_file(result)
with open('/tmp/output.txt', 'r') as output:
self.assertEqual(output.read(), '1 2 66\n3 1 11\n')
def test_result(self):
self.scoreboard.create()
with open('/tmp/output.txt', 'r') as output:
self.assertEqual(output.read(), '1 2 66\n3 1 11\n')
def test_create_raise_ioerror(self):
def ioerror():
scoreboard = ScoreBoard('scoreboard/fixtures/test_file_incorrect.txt')
scoreboard.create()
self.assertRaises(IOError, ioerror)
def setUp(self):
self.pathfile = 'scoreboard/fixtures/test_file.txt'
self.scoreboard = ScoreBoard(self.pathfile)
