class Level(object):
def __init__(self):
self.bounds = Rect((0,0), LEVEL_SIZE)
print "self.bounds = ", self.bounds
self.ceilingCoord = 0
self.floorCoord = self.bounds.height - 40
self.leftWall = 0
self.rightWall = self.bounds.width - 40
# make rects for level
self.blocks = Group(Block(0,0,40,self.bounds.height), # left wall
Block(self.bounds.width - 40, 0, 40, self.bounds.height), # right wall
Block(0, self.bounds.height - 40, self.bounds.width, 40), # floor
Block(200,self.floorCoord-80, 20, 80), # extra bit
Spike(350, self.floorCoord, 40), # DEATH SPIKE
NinjaStar(350, self.floorCoord - 130) # ninja star
)
# render
self.render_background()
def render_background(self):
self.background = Surface(self.bounds.size)
self.background.fill((80,80,80))
self.blocks.draw(self.background)
class Player(Sprite):
def __init__(self, game):
Sprite.__init__(self)
self.game = game
self.image = game.get_tile_surface('rot.hoch')
self.mask = mask.from_surface(self.image)
self.g = Group(self)
self.pos = Vector(300, 510)
self.speed = 4
self.direction = RIGHT
def set_direction(self, direction):
if direction in [LEFT, RIGHT]:
self.direction = direction
def get_shot(self):
return Shot(self.game, (self.pos.x, self.pos.y - 16), UP)
def move(self):
self.pos += self.direction * self.speed
if self.pos.x < MIN_X:
self.pos.x = MIN_X
elif self.pos.x > MAX_X:
self.pos.x = MAX_X
def draw(self):
self.rect = Rect(self.pos.x, self.pos.y, 32, 32)
self.g.draw(self.game.screen.display)
def start( self ):
Game.started = True
level = gamelevel.levels[ str( Game.game_level ) ]
xmax, ymax = self.surface.get_size()
self.stopped_balls = 0
# Starter ball
starter = ball.StarterBall( 30, pygame.Color( 255, 0, 0 ) )
starter_group = Group( starter )
starter_group.draw( self.surface )
# All balls
sprites = [
ball.GameBall( i, level[ 'ball_size' ], level[ 'ball_speed' ] , level[ 'expanded_ball_size' ], xmax, ymax )
for i in range( level[ 'number_of_balls' ] )
]
# Group
group = Group( sprites )
# Draw
group.draw( self.surface )
# Set instance variables
self.sprites, self.group, self.starter, self.starter_group = sprites, group, starter, starter_group
# blank stuff
self.blank = pygame.Surface(( level[ 'ball_size'] * 2 , level[ 'ball_size' ] * 2) )
self.blank = self.blank.convert_alpha()
class ExplorableScreen(GameScreen):
def __init__(self, config, model):
super(ExplorableScreen, self).__init__(config, model)
def setup(self):
super(ExplorableScreen, self).setup()
pastel_flowers = Image(os.path.join("sample_sprites", "tiles", "png", "pastel_flowers.png"))
grass = Image(os.path.join("sample_sprites", "tiles", "png", "grass.png"))
images = (pastel_flowers, grass)
# XXX Just a demo, do not try this at home: this (rightly!) assumes that
# pastel_flowers and grass have the same dimensions
visible_width = int(self.screen_dimensions[GameConfig.WIDTH_INDEX] / pastel_flowers.width)
visible_height = int(self.screen_dimensions[GameConfig.HEIGHT_INDEX] / pastel_flowers.height)
area_tile_size = (visible_width + 2) * (visible_height + 2)
self.tiles = Group()
for i in range(area_tile_size):
img = random.choice(images)
img_xpos = img.width * (i % visible_width)
img_ypos = img.height * (i % visible_height)
self.tiles.add(PyRoSprite(img.clone((img_xpos, img_ypos))))
def draw_screen(self, window):
self.tiles.draw(window)
self.tiles.update()
class Scoreboard():
def __init__(self, ai_setting, screen, stats):
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_setting = ai_setting
self.stats = stats
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
# -1 means multi 10
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color, self.ai_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_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True, self.text_color, self.ai_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.ai_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):
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_setting, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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)
# draw ships
self.ships.draw(self.screen)
class CollectCoinMicrogame(Microgame):
def __init__(self):
# TODO: Initialization code here
Microgame.__init__(self)
self.coins = coin(0) #coin(locals.HEIGHT + 70)]
self.ironman = ironman()
self.sprites = Group(self.ironman, self.coins)
self.time = pygame.time.get_ticks()
def start(self):
# TODO: Startup code here
music.load(os.path.join("games", "catching", "super_mario_levels.wav"))
music.play()
def stop(self):
# TODO: Clean-up code here
music.stop()
self.lose()
def update(self, events):
# TODO: Update code here
self.sprites.update()
ctrls = pygame.key.get_pressed()
if ctrls[K_q]:
self.win()
elif ctrls[K_a] or ctrls[K_LEFT]:
self.ironman.rect.x = max(self.ironman.rect.x - 30, 0)
elif ctrls[K_d] or ctrls[K_RIGHT]:
self.ironman.rect.x = min(locals.WIDTH - 68, self.ironman.rect.x + 30)
if self.coins.rect.colliderect(self.ironman):
# self.time = pygame.time.get_ticks()
# self.sprites.remove(self.coins)
# print str(self.time) + " " + str(pygame.time.get_ticks())
# if self.time + 3000 <= pygame.time.get_ticks():
# self.coins = coin(0)
# self.sprites.add(self.coins)
self.coins.rect.y = 0
self.coins.velocity = 0
self.coins.rect.left = randint(0, locals.WIDTH - COIN_WIDTH)
# self.sprites.update()
elif self.coins.rect.top > locals.HEIGHT:
self.lose()
def render(self, surface):
# TODO: Rendering code here
surface.fill(Color(0, 0, 0))
imgpath = os.path.join("games", "catching", "8bitsky.jpg")
test_image = pygame.image.load(imgpath)
surface.blit(test_image,(0,0))
self.sprites.draw(surface)
def get_timelimit(self ):
# TODO: Return the time limit of this game (in seconds)
return 15
class Panel:
def __init__(self, world_map):
self.world_map = world_map
self.group = Group()
self.energy_bar = EnergyBar(world_map.main_character, 15, 10, self.group)
self.energy_bar.put(75, 13)
self.energy_bar = LifeBar(world_map.main_character, 15, 10, self.group)
self.energy_bar.put(75, 30)
self.rect = Rect(0, 0, SCREEN_W, 40)
self.background = data.load_image('panel.png')
font = Font(data.filepath('fonts', 'vera.ttf'), 12)
#font.set_bold(True)
self.twister_text = font.render("Twister:", True, (0,0,0))
self.life_text = font.render("Life:", True, (0,0,0))
self.world_text = font.render("World: %s" % world_map.name, True, (0,0,0))
class TimeText(Sprite):
def __init__(self, world_map, *groups):
Sprite.__init__(self, *groups)
self.world_map = world_map
def update(self, *args):
time = self.world_map.time
time_str = self.world_map.get_time()
if time < 60:
color = (170, 0, 0)
elif time < 120:
color = (255, 100, 0)
else:
color = (0, 0, 0)
self.image = font.render("Time: %s"% time_str , True, color)
self.rect = self.image.get_rect()
self.rect.move_ip(500, 0)
TimeText(world_map, self.group)
self.key = KeyItem(world_map)
self.key.put(620, 20)
self.key.remove(self.key.groups())
def draw(self, screen):
if self.world_map.got_key:
self.key.add(self.group)
screen.set_clip(self.rect)
self.group.clear(screen, self.background)
self.group.update()
self.group.draw(screen)
def draw_background(self, screen):
screen.blit(self.background, (0,0))
screen.blit(self.twister_text, (10, 0))
screen.blit(self.life_text, (10, 17))
screen.blit(self.world_text, (500, 17))
class Options:
"Permite conocer y alterar las opciones del juego."
def __init__(self, world):
self.world = world
self.sprites = Group()
self.background = load_image("options.png", "scenes")
options = [
("Actual mode: window", "Actual mode: fullscreen",
self.on_change_fs, common.options.fullscreen),
("Audio: disable", "Audio: enable",
self.on_change_audio, common.audio.enabled),
("Sound Volume:", common.options.sound_volume,
self.on_change_sound_volume),
("Music Volume:", common.options.music_volume,
self.on_change_music_volume),
("Exit", self.on_return_to_main_menu),
]
self.menu = menu.Menu(230, 250, self.sprites, world.font, options)
def update(self):
self.menu.update()
def draw(self, screen):
screen.blit(self.background, (0, 0))
self.sprites.draw(screen)
pygame.display.flip()
def on_return_to_main_menu(self):
import scenes
self.world.change_state(scenes.mainmenu.MainMenu(self.world))
def on_change_fs(self):
result = pygame.display.toggle_fullscreen()
return result
def on_change_audio(self):
new_state = not common.audio.enabled
common.audio.set_enabled(new_state)
return 1
def on_change_sound_volume(self):
common.audio.set_sound_volume(0.5)
def on_change_music_volume(self):
common.audio.set_music_volume(0.5)
def handle_event(self, event):
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.on_return_to_main_menu()
self.menu.update_control(event)
class VerticalToolbar(pygame.sprite.Sprite):
def __init__(self, editor_level, font_manager):
pygame.sprite.Sprite.__init__(self)
self.editor_level = editor_level
self.selected = None
self.position = Point(constants.HORIZONTAL_TILES, 0)
self.width = editor_constants.RIGHT_BAR_RATIO
self.height = constants.VERTICAL_TILES
self.options = Group()
self.hotkeys = {}
top = editor_constants.RIGHT_BAR_ITEM_SPACING
for (name, data) in editor_constants.ENTITY_DATA:
option = ToolbarOption(top, name, data, font_manager)
if self.selected is None:
self.select(option)
self.options.add(option)
top += editor_constants.RIGHT_BAR_ITEM_RATIO + editor_constants.RIGHT_BAR_ITEM_SPACING
self.hotkeys[data.hotkey] = option
self.update_graphics()
def hotkey(self, hotkey):
if hotkey in self.hotkeys:
self.select(self.hotkeys[hotkey])
def select(self, option):
if self.selected is not None:
self.selected.toggle_select()
self.selected = option
self.selected.toggle_select()
self.editor_level.entity_to_create = option.name
def left_click(self, position, pressed):
for option in self.options:
rect = pygame.Rect(option.position.scale(constants.TILE_SIZE), (constants.TILE_SIZE * option.size, constants.TILE_SIZE * option.size))
if rect.collidepoint(position.scale(constants.TILE_SIZE)):
self.select(option)
def update_graphics(self):
width = int(round(self.width * constants.TILE_SIZE))
height = int(round(self.height * constants.TILE_SIZE))
self.image = pygame.Surface([width, height])
self.image.fill(editor_constants.TOOLBAR_COLOR)
self.rect = self.image.get_rect(topleft=self.position.scale(constants.TILE_SIZE))
def draw(self, screen):
self.options.draw(screen)
class Logo:
"Escena que muestra el logotipo del grupo losersjuegos."
def __init__(self, world):
self.world = world
self.sprites = Group()
self._create_sprites()
self._reset_timer()
def _reset_timer(self):
self.time_out = 50
def update(self):
key = pygame.key.get_pressed()
if key[pygame.K_ESCAPE]:
self.world.state = Logo(self.world)
self._reset_timer()
return
else:
self.sprites.update()
if self.time_out < 1 or key[pygame.K_RETURN]:
self.world.change_state(scenes.mainmenu.MainMenu(self.world))
self.time_out -= 1
def draw(self, screen):
screen.fill((92, 123, 94))
self.sprites.draw(screen)
pygame.display.flip()
def _create_sprites(self):
steps = [0, 0, 0, 1, 2, 3, 4]
losers = SimpleAnimation('logo', 'losers_5.png', steps, 2)
sprite_losers = LogoSpriteAnimated(losers, LEFT, 190, 190)
steps2 = [0, 0, 0, 1, 2, 3, 4]
juegos = SimpleAnimation('logo', 'juegos_5.png', steps2, 2)
sprite_juegos = LogoSpriteAnimated(juegos, RIGHT, 390, 190)
steps3 = [0, 0, 0, 1, 1, 2, 3]
ceferino = SimpleAnimation('logo', 'ceferino_4.png', steps3, 2)
sprite_ceferino = LogoSpriteAnimated(ceferino, RIGHT, 40, 160)
self.sprites.add([sprite_juegos, sprite_losers, sprite_ceferino])
def handle_event(self, event):
pass
def game():
# init
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
clock = pygame.time.Clock()
dude = PlayerShip(260, 500, screen.get_rect())
dude_grp = GroupSingle(dude)
enemies = Group()
enemies.add(Burger(200, 200, screen.get_rect()))
enemies.add(Hotdog(100, 100, screen.get_rect()))
#loop
while True:
# input
for evt in pygame.event.get():
if evt.type == QUIT:
return
elif evt.type == KEYDOWN and evt.key == K_ESCAPE:
return
elif evt.type == KEYDOWN and evt.key == K_a:
dude.dx = -10
elif evt.type == KEYDOWN and evt.key == K_d:
dude.dx = 10
elif evt.type == KEYUP and evt.key == K_a and dude.dx == -10:
dude.dx = 0
elif evt.type == KEYUP and evt.key == K_d and dude.dx == 10:
dude.dx = 0
elif evt.type == KEYDOWN and evt.key == K_SPACE and dude.alive():
dude.shoot()
# update
clock.tick(FPS)
dude.update()
enemies.update()
dude.bullets.update()
pygame.sprite.groupcollide(enemies, dude.bullets, 1, 1)
pygame.sprite.groupcollide(dude_grp, enemies, 1, 0)
# draw
screen.fill(BLACK)
dude_grp.draw(screen)
enemies.draw(screen)
dude.bullets.draw(screen)
pygame.display.flip()
class KoalaKross(Microgame):
def __init__(self):
Microgame.__init__(self)
self.rect= Rect(0,0, locals.WIDTH, locals.HEIGHT)
## surface=pygame.display.set_mode((1024,768))
## surface.fill(Color(0,0,250))
koala=Koala(self)
self.panda1=Panda(200,100,0,2)
self.panda2=Panda(500,100,0,2)
self.bread=Bread(self)
self.sprites=Group((koala,self.panda1,self.panda2,self.panda3))
self.clock=pygame.time.Clock()
def start():
pass
def stop():
pass
def update(self):
time=pygame.time.get_ticks()
self.sprites.update()
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key==K_DOWN:
koala.velocity=(0,-3)
elif event.key==K_UP:
koala.velocity=(3,0)
elif event.key == K_Right:
koala.velocity=(3,0)
elif event.key == K_Left:
koala.velocity=(-3,0)
elif event.key == K_q:
self.lose()
elif event.type == KEYUP:
koala.velocity=(0,0)
def render (self, surface):
## Surface=display.set_mode((1024,768))
surface.fill.Color(0,0,0)
self.sprites.draw(surface)
class evade(Microgame):
def __init__(self):
Microgame.__init__(self)
self.e_icicles = [e_icicle(0), e_icicle(locals.HEIGHT + 70),e_icicle(locals.HEIGHT+100),e_icicle(locals.HEIGHT+10),e_icicle(100),
e_icicle(100),e_icicle(700),e_icicle(300),e_icicle(500)]
self.e_eskimo = eskimo()
self.sprites = Group(self.e_eskimo, *self.e_icicles)
def start(self):
music.load(os.path.join("games", "evadeFull", "alt_song.wav"))
music.play()
def stop(self):
music.stop()
self.lose()
def update(self, events):
self.sprites.update()
keys = pygame.key.get_pressed()
if keys[K_q]:
self.win()
elif (keys[K_RIGHT] or keys[K_d]) and (keys[K_LEFT] or keys[K_a]):
pass
elif keys[K_LEFT] or keys[K_a]:
self.e_eskimo.rect.x = max(self.e_eskimo.rect.x - 15, 0)
elif keys[K_RIGHT] or keys[K_d]:
self.e_eskimo.rect.x = min(locals.WIDTH -57, self.e_eskimo.rect.x + 15)
for icicle in self.e_icicles:
if self.e_eskimo.rect.colliderect(icicle.rect):
music.stop()
self.lose()
def render(self, surface):
surface.fill((0, 0, 0))
imgpathh = os.path.join("games", "evadeFull", "tile.png")
test_image = pygame.image.load(imgpathh)
surface.blit(test_image,(0,0))
self.sprites.draw(surface)
def get_timelimit(self):
return 15
class Board:
def __init__(self, width: int, height: int):
super().__init__()
self.width = width
self.height = height
self.players = Group()
self.walls = Group()
for w in range(width >> 1):
for h in range(height >> 1):
wall = Wall()
wall.rect.x = PPM * (2 * w + 1)
wall.rect.y = PPM * (2 * h + 1)
self.walls.add(wall)
def draw(self, canvas):
self.walls.draw(canvas)
self.players.draw(canvas)
def update(self, dt):
self.players.update(dt)
class MainMenu:
"Escena del menú principal."
def __init__(self, world):
self.world = world
self.sprites = Group()
self.background = load_image("mainmenu.png", "scenes")
options = [
("Start a new game", self.on_start_new_game),
("Options", self.on_options),
("About this game", self.on_about),
("Exit", self.on_exit),
]
self.menu = menu.Menu(330, 300, self.sprites, world.font, options)
def update(self):
self.menu.update()
def draw(self, screen):
screen.blit(self.background, (0, 0))
self.sprites.draw(screen)
pygame.display.flip()
def on_exit(self):
sys.exit(0)
def on_start_new_game(self):
import game
self.world.change_state(game.Game(self.world))
def on_about(self):
from scenes.about import About
self.world.change_state(About(self.world))
def on_options(self):
from scenes.options import Options
self.world.change_state(Options(self.world))
def handle_event(self, event):
self.menu.update_control(event)
class Level(object):
def __init__(self):
self.bounds = Rect((0,0), LEVEL_SIZE)
# make rects for level
self.blocks = Group(
Block(0,0,40,self.bounds.height), # left wall
Block(self.bounds.width - 40, 0, 40, self.bounds.height), # right wall
Block(0, self.bounds.height - 40, self.bounds.width, 40), # floor
Block(self.bounds.centerx + 60, self.bounds.height - 120, 40, 120), # random thing
Block(0, self.bounds.height - 50, 80, 50),
Block(self.bounds.centerx + 160, self.bounds.height - 140, self.bounds.width, 40)
)
# render
self.render_background()
def render_background(self):
self.background = Surface(self.bounds.size)
self.background.fill((80,80,80))
self.blocks.draw(self.background)
class Game(Application):
title = "Spaceships"
screen_size = 800, 600
def __init__(self):
Application.__init__(self)
self.bounds = self.screen.get_rect()
self.ships = Group()
self.spawners = [ TieSpawner(2000, self.ships, self.bounds) ]
def update(self):
dt = self.clock.get_time()
self.ships.update(dt)
for spawner in self.spawners:
spawner.update(dt)
def draw(self, screen):
screen.fill((0,0,0))
self.ships.draw(screen)
class InvadersGame:
def __init__(self):
self.game = Game()
floorframe = Frame(self.game.screen, Rect(0, 542, MAX_X + 36, 596))
self.floor = TiledMap(self.game, floorframe)
self.floor.fill_map('#', (25, 2))
self.player = Player(self.game)
self.aliens = Group()
self.create_aliens()
self.shots = Group()
self.alien_shots = Group()
def create_aliens(self):
for i in range(4):
for j in range(20):
direction = [LEFT, RIGHT][i % 2]
alien = Alien(self.game, Vector(j * 32 + 32, i * 64), direction)
self.aliens.add(alien)
def shoot(self):
shot = self.player.get_shot()
self.shots.add(shot)
def draw(self):
self.game.screen.clear()
self.player.draw()
self.shots.draw(self.game.screen.display)
self.alien_shots.draw(self.game.screen.display)
self.aliens.draw(self.game.screen.display)
self.floor.draw()
def update(self):
self.player.move()
self.shots.update()
self.alien_shots.update()
self.aliens.update()
for a in self.aliens:
shot = a.get_shot()
if shot:
self.alien_shots.add(shot)
self.draw()
groupcollide(self.shots, self.aliens, True, True, collided=collide_mask)
if spritecollideany(self.player, self.alien_shots, collided=collide_mask):
self.game.exit()
if not self.aliens:
self.game.exit()
def run(self):
self.game.event_loop(figure_moves=self.player.set_direction,
draw_func=self.update, keymap={K_SPACE: self.shoot}, delay=30)
class Level(object):
def __init__(self, name):
self.bounds = Rect((0,0,), LEVEL_SIZE)
self.blocks = Group()
self.lethal = Group()
self.win = Group()
self.loadData(name)
self.spawnPoint = (20,20)
self.render_background()
def render_background(self):
self.background = Surface(self.bounds.size)
self.background.fill((0,0,0))
self.blocks.draw(self.background)
self.lethal.draw(self.background)
self.win.draw(self.background)
def loadData(self, name):
ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(ROOT_DIR, 'data')
path = os.path.join(DATA_DIR, name) + '.lvl'
with open(path, 'r') as f:
data = f.read().strip().split('\n')
width = 20
height = 20
for y, row in enumerate(data):
for x,c in enumerate(row):
loc = (x*width, y*height)
if c == '.':
self.blocks.add(Block(loc))
elif c == '!':
self.lethal.add(Lethal(loc))
elif c == "^":
self.win.add(Win(loc))
class Scoreboard():
"""显示得分信息的类"""
def __init__(self, ai_settings, screen, stats):
"""初始化显示得分涉及的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# 显示得分信息时使用的字体
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# 准备初始得分图像
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_level(self):
"""将等级转换为渲染的图像"""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.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):
"""显示还余下多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_score(self):
"""将得分转换为一副渲染的图像"""
rounded_score = int(round(self.stats.score, -1))
#print(rounded_score)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.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_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.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 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)
class Scoreboard:
""" A class for reporting game information. """
def __init__(self, ai_game):
""" Initialize scoreboards attributes. """
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for scoring information.
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score images.
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
""" Turn the score into a redered image. """
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(
score_str, True, self.text_color, self.settings.bg_color)
# Display the score at the top right of the screen.
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):
"Turn the high score into a rendered image."
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(
high_score_str, True, self.text_color, self.settings.bg_color)
# Center the high score at the top of the screen.
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):
""" Turn the level into a rendered image. """
level_str = str(self.stats.level)
self.level_image = self.font.render(
level_str, True, self.text_color, self.settings.bg_color)
# Position the level below the score.
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):
""" Show how many ships are left. """
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
""" Draw score and level to the screen. """
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)
def check_high_score(self):
"Check to see if there's a new high score."
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
class Game():
def __init__(self):
pygame.init()
self.ai_settings = Settings()
self.screen = pygame.display.set_mode(
(self.ai_settings.screen_width, self.ai_settings.screen_height))
pygame.display.set_caption("Inwazja obcych")
# Utworzenie przycisku Gra
self.play_button = Button(self.ai_settings, self.screen, 'Gra')
# Utworzenie egzemplarza przenaczonego do przechowywania danych
# statystycznych gry oraz utworzenie egzemplarza klasy Scoreboard
self.stats = GameStats(self.ai_settings)
self.sb = Scoreboard(self.ai_settings, self.screen, self.stats)
#Utworzenie statku kosmicznego, grupy pocisków oraz grupy obcych
self.ship = Ship(self.ai_settings, self.screen)
self.bullets = Group()
self.aliens = Group()
# Utworzenie floty obcych
self.create_fleet()
def run(self):
while True:
self.check_events()
if self.stats.game_active:
self.ship.update()
self.update_bullets()
self.update_aliens()
self.update_screen()
def create_fleet(self):
'''Utworzenie pełnej floty obcych.'''
alien = Alien(self.ai_settings, self.screen)
number_aliens_x = self.get_number_aliens_x(alien.rect.width)
number_rows = self.get_number_rows(alien.rect.height)
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self.create_alien(alien_number, row_number)
def get_number_aliens_x(self, alien_width):
'''Ustalenie liczby obcych, którzy zmieszczą się w rzędzie.'''
available_space_x = self.ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / (2 * alien_width))
return number_aliens_x
def get_number_rows(self, alien_height):
'''Ustalenie ile rzędów obcych zmieści się na ekranie'''
available_space_y = (self.ai_settings.screen_height -
3 * alien_height - self.ship.rect.height)
number_rows = int(available_space_y / (2 * alien_height))
return number_rows
def create_alien(self, alien_number, row_number):
'''Utwórz nowego obcego.'''
alien = Alien(self.ai_settings, self.screen)
alien_width = alien.rect.width
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def check_events(self):
'''Reakcja na zdarzenia generowane przez klawiaturę i mysz.'''
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self.check_keydown_events(event)
elif event.type == pygame.KEYUP:
self.check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
self.check_play_button(mouse_x, mouse_y)
def check_keydown_events(self, event):
'''Reakcja na naciśnięcie klawisza.'''
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_SPACE:
self.fire_bullet()
elif event.key == pygame.K_g:
self.start_game()
elif event.key == pygame.K_q:
sys.exit()
def fire_bullet(self):
# Utworzenie nowego pocisku i dodanie go do grupy pocisków
if len(self.bullets) < self.ai_settings.bullets_allowed:
new_bullet = Bullet(self.ai_settings, self.screen, self.ship)
self.bullets.add(new_bullet)
def start_game(self):
'''Rozpoczęcie gry poprzez wywołanie domyślnych ustawień.'''
if not self.stats.game_active:
# Wyzerowanie ustawień dotyczących gry.
self.ai_settings.initialize_dynamic_settings()
# Ukrycie kursora myszy
pygame.mouse.set_visible(False)
# Wyzerowanie danych statystycznych gry
self.stats.reset_stats()
self.stats.game_active = True
# Wyzerowanie obrazów tablicy wyników.
self.sb.prep_score()
self.sb.prep_high_score()
self.sb.prep_level()
# Usunięcie zawartości list aliens i bullets
self.aliens.empty()
self.bullets.empty()
# Utworzenie nowej floty i wyśrodkowanie statku
self.create_fleet()
self.ship.center_ship()
def check_keyup_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def check_play_button(self, mouse_x, mouse_y):
'''Rozpoczęcie nowej gry po kliknięciu przycisku Gra przez użytkownika'''
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not self.stats.game_active:
self.start_game()
def update_bullets(self):
self.bullets.update()
# Usunięcie pocisków, które znajdą się poza ekranem
for bullet in self.bullets.copy():
if bullet.rect.bottom < 0:
self.bullets.remove(bullet)
self.check_bullet_alien_collisions()
def check_bullet_alien_collisions(self):
'''Reakcja na kolizję między pociskiem i obcym.'''
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
for aliens in collisions.values():
self.stats.score += self.ai_settings.alien_points * len(aliens)
self.sb.prep_score()
self.check_high_score()
if len(self.aliens) == 0:
# Jeżeli cała flota została zniszczona, gracz przechodzi na kolejny poziom.
self.bullets.empty()
self.ai_settings.increase_speed()
# Inkrementacja numeru poziomu.
self.stats.level += 1
self.sb.prep_level()
self.create_fleet()
def check_high_score(self):
'''Sprawdzenie, czy mamy nowy najlpeszy wynik osiągnięty dotąd w grze.'''
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.sb.prep_high_score()
def update_aliens(self):
'''Uaktualnienie położenia wszystkich obcych we flocie'''
self.check_fleet_edges()
self.aliens.update()
# Wykrywanie kolizji między obcym i statkiem
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.ship_hit()
# Wyszukiwanie obcych docierających do dolnej krawędzi ekranu
self.check_aliens_bottom()
def check_fleet_edges(self):
'''Odpowiednia reakcja, gdy obcy dotrze do krawędzi ekranu.'''
for alien in self.aliens.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
def change_fleet_direction(self):
'''Przesunięcie całej floty w dół i zmiana kierunku, w którym się ona porusza.'''
for alien in self.aliens.sprites():
alien.rect.y += self.ai_settings.fleet_drop_speed
self.ai_settings.fleet_direction *= -1
def ship_hit(self):
'''Reakcja na uderzenie obcego w statek.'''
if self.stats.ships_left > 0:
# Zmniejszenie wartości przechowywanej w ships_left
self.stats.ships_left -= 1
# Uaktualnienie tablicy wyników.
self.sb.prep_ships()
# Usunięcie zawartości list aliens i bullets
self.aliens.empty()
self.bullets.empty()
# Utworzenie nowej floty i wyśrodkowanie statku
self.create_fleet()
self.ship.center_ship()
# Pauza
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def check_aliens_bottom(self):
'''Sprawdzenie, czy którykolwiek obcy dotarł do dolnej krawędzi ekranu'''
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self.ship_hit()
break
def update_screen(self):
'''Uaktualnienie obrazów na ekranie i przejście do nowego ekranu.'''
self.screen.fill(self.ai_settings.bg_color)
# Ponowne wyświetlenie wszystkich pocisków pod warstwami statku kosmicznego i obcych
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.ship.blitme()
self.aliens.draw(self.screen)
# Wyświetlenie informacji o punktacji.
self.sb.show_score()
# Wyświetlenie przycisku tylko wtedy, gdy gra jest nieaktywna
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
class PongMicrogame(Microgame):
'''
Simple Pong Microgame.
An example Microgame. Single bounce Pong.
Attributes:
rect - the bounding box of the playfield
ball - the ball of the microgame
lbat - the left-hand bat of this microgame, ai-controlled
rbat - the right-hand bat of this microgame, user-controlled
sprites - the sprite group that contains the sprites of the game
timeSinceWin - the time in (ms) when the player won the game, or 0 if the
game has not been won yet
'''
def __init__(self):
Microgame.__init__(self)
self.rect = Rect(0, 0, locals.WIDTH, locals.HEIGHT)
speed = BALL_SPEED_BASE
widthqrt = self.rect.width / 4
heightqrt = self.rect.height / 4
self.ball = Ball(self, 150, randint(heightqrt, heightqrt * 3), \
randint(speed, speed + BALL_SPEED_RANGE), \
choice([speed, -speed]))
self.lbat = Bat(100, randint(heightqrt, heightqrt * 3), \
self.rect, self.ball, True)
self.rbat = Bat(self.rect.width - 150, \
randint(heightqrt, heightqrt * 3), \
self.rect, self.ball)
self.sprites = Group((self.ball, self.lbat, self.rbat))
self.timeSinceWin = 0
def start_win_countdown(self):
'''
Starts the successful hit countdown --- once this is up, the player wins
the game.
'''
self.timeSinceWin = pygame.time.get_ticks()
def start(self):
music.load('games/pong/music.mp3')
music.play(0, 0.5)
def stop(self):
music.stop()
def update(self, events):
time = pygame.time.get_ticks()
if self.timeSinceWin > 0 and \
time > self.timeSinceWin + TIME_TO_WIN_AFTER_BOUNCE:
self.win()
self.sprites.update()
for event in events:
if event.type == KEYDOWN:
if event.key == K_UP:
self.rbat.direction = -1
elif event.key == K_DOWN:
self.rbat.direction = 1
if event.type == KEYUP:
if event.key == K_UP or event.key == K_DOWN:
self.rbat.direction = 0
def render(self, surface):
surface.fill(Color(0, 0, 0))
self.sprites.draw(surface)
def get_timelimit(self):
return 10
def run_game():
global sco, enemy_type
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()
alien = Alien(ai_settings, screen)
alien_width = alien.rect.width
available_spase_x = ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_spase_x / (2 * alien_width))
number_rows = get_number_rows(ai_settings, ship.rect.height,
alien.rect.height)
b = bg(ai_settings, screen, ship)
b.draw_bg()
alien = Alien(ai_settings, screen)
aliens.add(alien)
# print(alien.rect.y)
#reate_alien(ai_settings,screen,aliens,alien_number,row_number)
# aliens.add(alien)
bg_color = (20, 250, 200)
while True:
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1:
first = randint(0, 220)
second = randint(0, 220)
three = randint(0, 220)
ai_settings.bg_color = (first, second, three)
if event.key == pygame.K_b:
sys.exit()
if event.key == pygame.K_RIGHT:
ship.movin_right = True
if event.key == pygame.K_SPACE:
if len(bullets) < ai_settings.bullet_allowed:
new_bullet = Bullet(ai_settings, screen, ship)
bullets.add(new_bullet)
if event.key == pygame.K_LEFT:
ship.movin_left = True
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
ship.movin_right = False
if event.key == pygame.K_LEFT:
ship.movin_left = False
ship.update()
bullets.update()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
screen.fill(ai_settings.bg_color)
for bullet in bullets.sprites():
bullet.draw_bullet()
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
ship.blitme()
aliens.draw(screen)
alien.blitme()
aliens.update()
if pygame.sprite.spritecollideany(ship, aliens):
if enemy_type == 0:
do_new_alien(ai_settings, alien)
sco = sco + 1
tre = randint(0, 1)
enemy_type = tre
if tre == 1:
alien.image = pygame.image.load('bomb.gif')
else:
alien.image = pygame.image.load('cherry.gif')
#print(enemy_type)
else:
print('you lose')
break
if alien.rect.y >= 800:
if enemy_type == 1:
#print("OJF")
do_new_alien(ai_settings, alien)
enemy_type = 0
tre = randint(0, 1)
enemy_type = tre
if tre == 1:
alien.image = pygame.image.load('bomb.gif')
else:
alien.image = pygame.image.load('cherry.gif')
#print(enemy_type)
else:
print('you lose, your score is ', sco)
break
pygame.display.flip()
class Scoreboard():
"""显示得分信息的类"""
def __init__(self, ai_settings, screen, stats):
"""初始化显示得分涉及的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# 显示得分信息时使用的字体设置
self.text_color = (50, 50, 50)
self.font = pygame.font.SysFont("Agency FB", 40)
# 准备初始图像
self.prep_str_score()
self.prep_num_score()
self.prep_str_high_score()
self.prep_num_high_score()
self.prep_str_level()
self.prep_num_level()
self.prep_ships()
def prep_str_score(self):
"""初始化字符串‘score’图像"""
self.score_image = self.font.render("Scores: ", True, self.text_color,
self.ai_settings.bg_color)
self.score_image_rect = self.score_image.get_rect()
self.score_image_rect.centerx = self.screen_rect.right - 150
self.score_image_rect.y = 0
def prep_num_score(self):
"""初始化得分数据图像"""
rounded_num_score = round(self.stats.score, -1)
self.num_score = "{:,}".format(rounded_num_score)
self.num_score_image = self.font.render(self.num_score, True,
self.text_color,
self.ai_settings.bg_color)
self.num_score_image_rect = self.num_score_image.get_rect()
self.num_score_image_rect.x = self.screen_rect.right - 100
self.num_score_image_rect.y = 0
def prep_str_high_score(self):
"""初始化字符串‘High Scores’图像"""
self.high_score_image = self.font.render("High Scores: ", True,
self.text_color,
self.ai_settings.bg_color)
self.high_score_image_rect = self.high_score_image.get_rect()
self.high_score_image_rect.x = 10
self.high_score_image_rect.y = 0
def prep_num_high_score(self):
"""初始化最高得分数据"""
self.num_high_score = "{:,}".format(self.stats.high_score)
self.num_high_score_image = self.font.render(self.num_high_score, True,
self.text_color,
self.ai_settings.bg_color)
self.num_high_score_image_rect = self.num_high_score_image.get_rect()
self.num_high_score_image_rect.x = 180
self.num_high_score_image_rect.y = 0
def prep_str_level(self):
"""初始‘Level’图像"""
self.level_image = self.font.render("Lv.", True, self.text_color,
self.ai_settings.bg_color)
self.level_image_rect = self.level_image.get_rect()
self.level_image_rect.x = self.screen_rect.right - 80
self.level_image_rect.y = 45
def prep_num_level(self):
"""初始等级数据"""
self.num_level = str(self.stats.level)
self.num_level_image = self.font.render(self.num_level, True,
self.text_color,
self.ai_settings.bg_color)
self.num_level_image_rect = self.num_level_image.get_rect()
self.num_level_image_rect.x = self.screen_rect.right - 35
self.num_level_image_rect.y = 45
def prep_ships(self):
"""显示还有多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.image = pygame.image.load('images\ship_icon.bmp')
ship.rect.x = 570 + 35 * ship_number
ship.rect.y = 10
self.ships.add(ship)
def blitme(self):
"""绘制图像‘Scores:’和得分数据"""
self.screen.blit(self.score_image, self.score_image_rect)
self.screen.blit(self.num_score_image, self.num_score_image_rect)
self.screen.blit(self.level_image, self.level_image_rect)
self.screen.blit(self.num_level_image, self.num_level_image_rect)
# 绘制飞船
self.ships.draw(self.screen)
self.screen.blit(self.high_score_image, self.high_score_image_rect)
self.screen.blit(self.num_high_score_image,
self.num_high_score_image_rect)
class ScoreBoard:
def __init__(self, ai_game):
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for score board
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
#Prepare the intial score image
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
#Turn the score into a rendered image.
score_str = str(self.stats.score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.bg_color)
#Display the score at the top right of the screen.
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 30
self.score_rect.top = 20
def prep_high_score(self):
high_score = round(self.stats.high_score,
-1) #round score to nearest 10
#high_score_str = "{:,}".format(high_score)
high_score_str = str(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.bg_color)
# Center the high score at the top of the screen.
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):
#Turn the level into a rendered image.
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.bg_color)
#Position the level below the score.
self.level_rect = self.level_image.get_rect()
#self.level_rect.right = self.score_rect.right - 300
#self.level_rect.bottom = self.score_rect.bottom
self.level_rect.left = self.screen_rect.left + 30
self.level_rect.top = 20
def prep_ships(self):
self.ships = Group() #make a instance of Group class
for ship_number in range(self.stats.ship_left):
ship = Ship(self.ai_game)
ship.rect.x = 100 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def check_high_score(self):
#Check to see if there's a new high score.
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
def show_score(self):
#Draw score to the screen.
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)
class Scoreboard:
"""现实得分信息"""
def __init__(self, ai_game):
"""初始化显示得分涉及的属性"""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# 准备包含最高得分和当前得分图像
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""将得分转换为一幅渲染的图像"""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.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 = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.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 check_high_score(self):
"""检查是否诞生了新的最高分"""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
def prep_level(self):
"""将等级转换渲染图"""
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.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):
"""显示还剩余多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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)
class SpaceGame(Microgame):
def __init__(self):
Microgame.__init__(self)
# TODO: Initialization code here
self.count = 0
self.spaceship = Spaceship()
self.bg = Background()
self.planet = Planet()
self.monster = Group(Monster())
self.earth = Group(EarthExp())
self.background = Group(self.bg)
self.sprites = Group(self.planet, self.spaceship)
self.is_win = False
self.is_lose = False
def generate_asteroid(self):
if self.count == 10:
if randint(0,1) == 0:
self.sprites.add(Asteroid(-10, randint(0, locals.HEIGHT - 400), 1))
else:
self.sprites.add(Asteroid(locals.WIDTH + 10, randint(0, locals.HEIGHT - 400), -1))
self.count = 0
else:
self.count += 1
def start(self):
# TODO: Startup code here
music.load(join("games","space","music","space_song.ogg"))
music.play()
def stop(self):
# TODO: Clean-up code here
music.stop()
def update(self, events):
# TODO: Update code here
self.background.update()
self.sprites.update()
#Make asteroids
self.generate_asteroid()
#Check if spaceship hits sides of screen
x_ship_left, _ = self.spaceship.rect.bottomleft
x_ship_right, _ = self.spaceship.rect.bottomright
if x_ship_left <= 0:
self.spaceship.x_velocity = 0
elif x_ship_right >= locals.WIDTH - 14:
self.spaceship.x_velocity = 0
#Check if spaceship hits top/bottom of screen sectioned to movement
_, y_ship_top = self.spaceship.rect.topleft
_, y_ship_bottom = self.spaceship.rect.bottomleft
if y_ship_top <= locals.HEIGHT - 300:
self.spaceship.y_velocity = 0
elif y_ship_bottom >= locals.HEIGHT - 20:
self.spaceship.y_velocity = 0
#Process user input
for event in events:
if event.type == KEYDOWN and event.key == K_LEFT:
if x_ship_left > 0:
self.spaceship.x_velocity -= VELOCITY_INC
elif event.type == KEYUP and event.key == K_LEFT:
self.spaceship.x_velocity = 0
elif event.type == KEYDOWN and event.key == K_RIGHT:
if x_ship_right < locals.WIDTH - 14:
self.spaceship.x_velocity += VELOCITY_INC
elif event.type == KEYUP and event.key == K_RIGHT:
self.spaceship.x_velocity = 0
elif event.type == KEYDOWN and event.key == K_UP:
if y_ship_top > locals.HEIGHT - 300:
self.spaceship.y_velocity -= VELOCITY_INC
elif event.type == KEYUP and event.key == K_UP:
self.spaceship.y_velocity = 0
elif event.type == KEYDOWN and event.key == K_DOWN:
if y_ship_bottom < locals.HEIGHT - 20:
self.spaceship.y_velocity += VELOCITY_INC
elif event.type == KEYUP and event.key == K_DOWN:
self.spaceship.y_velocity = 0
#music.load(join("games","space","music","Powerup7.wav"))
#music.play()
#Make win when spaceship hits planet
if self.planet.rect.colliderect(self.spaceship.rect):
sound_planet = pygame.mixer.Sound(join("games","space","music","Powerup.wav"))
sound_planet.play()
self.is_win = True
for each in self.sprites.sprites():
if isinstance(each, Asteroid):
if each.rect.colliderect(self.spaceship.rect):
sound_asteroid = pygame.mixer.Sound(join("games","space","music","Explosion.wav"))
sound_asteroid.play()
self.is_lose = True
#Creates win scree
if self.is_win:
self.sprites.empty()
self.background.empty()
self.sprites.add(Monster())
#Creates lose screen
elif self.is_lose:
self.sprites.empty()
self.background.empty()
self.sprites.add(EarthExp())
def render(self, surface):
# TODO: Rendering code here
surface.fill(Color(0, 0, 0))
self.background.draw(surface)
self.sprites.draw(surface)
def get_timelimit(self):
# TODO: Return the time limit of this game (in seconds, 0 <= s <= 15)
#raise NotImplementedError("get_timelimit")
return 15
class Main(object):
"""
creates and recieves input from the GUI
"""
SCREEN_SIZE = 800,600
FPS = 30
def __init__(self):
"""
no gui stuff yet, finishing the core components
"""
self.ROOT_DIR = os.path.dirname(sys.argv[0])
self.IMG_DIR = os.path.join(self.ROOT_DIR, "images")
self.DATA_DIR = os.path.join(self.ROOT_DIR, "database")
self.dbm = DataBaseManager(self.DATA_DIR)
pygame.init()
pygame.font.init()
self.MAIN_SCREEN = pygame.display.set_mode(self.SCREEN_SIZE)
self.MAIN_SCREEN_RECT = self.MAIN_SCREEN.get_rect()
self.openingImage,self.openingImageRect = loadImage(self.IMG_DIR, "GrocerySpy.jpg")
self.MAIN_SCREEN.blit(self.openingImage,
(self.MAIN_SCREEN_RECT.centerx - self.openingImageRect.width /2,
self.MAIN_SCREEN_RECT.centery - self.openingImageRect.height /2))
## make button here
startButton = Button(self.IMG_DIR, "textButton", (300,475), "menu", -1)
startButton.addText("Start Here")
# add that button to the list
self.buttonGroup = Group(startButton)
self.windowGroup = Group()
self.state = "prestart"
self.stateChanged = False
# set key repeats for scrolling windows
pygame.key.set_repeat(20, 20)
self.groceryList = GroceryList()
# variable for storing the state of the browseAll window if it is left
self.toggledRecipeNames = []
self.controlHeld = False
self.pasteDelayReset = 1000
self.pasteDelay = self.pasteDelayReset
def run(self):
done = False
while not done:
## input loop
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
## right click anything to have a pop up window
# appear at the cursor with more information about the thing
elif event.type == MOUSEBUTTONDOWN and event.button == 1:
self.handleLeftMouseClick(pygame.mouse.get_pos())
## arrow keys
elif event.type == KEYDOWN and event.key == K_DOWN:
self.attemptScroll(-3)
elif event.type == KEYDOWN and event.key == K_UP:
self.attemptScroll(3)
elif event.type == KEYDOWN and (event.key == K_RCTRL or event.key == K_LCTRL):
self.controlHeld = True
elif event.type == KEYUP and (event.key == K_RCTRL or event.key == K_LCTRL):
self.controlHeld = False
elif event.type == KEYDOWN and event.key == K_v:
if self.controlHeld:
if self.pasteDelay < 10:
self.doPaste()
self.pasteDelay = self.pasteDelayReset
## end input
if self.pasteDelay > 0:
self.pasteDelay -= 1
## change screen
if self.stateChanged:
## clear everything on the screen first
self.buttonGroup.empty()
self.windowGroup.empty()
self.MAIN_SCREEN.fill((0,0,0))
self.stateChanged = False
if self.state == "menu":
self.createMenu()
elif self.state == "browseAll":
self.setUpViewAll()
elif self.state == "viewGroceryList":
self.setUpViewGroceryList()
elif self.state == "addRecipe":
#print "here"
self.setUpRecipeAdder()
elif self.state == "search":
self.setUpSearchTextBox()
elif self.state == "deleteRecipe":
self.setUpDelete()
elif self.state == "exit":
done = True
## do stuff to update the new state
# after updates, draw
self.buttonGroup.draw(self.MAIN_SCREEN)
self.windowGroup.draw(self.MAIN_SCREEN)
pygame.display.flip()
pygame.quit()
def setUpViewAll(self):
x,y = self.SCREEN_SIZE
x-=100
viewAllWindow = ScrollableWindow(self.IMG_DIR, (x,y),self.SCREEN_SIZE, "recipeViewer")
viewAllWindow.addText(self.dbm.getAllRecipes())
#viewAllWindow.addText(self.dbm.getRandomRecipe())
viewAllWindow.updateState(self.toggledRecipeNames)
self.windowGroup.add(viewAllWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
## in one command, we call getAllRecipes() on the DBM, returning
# a string list of all the names, and pass that to the
# scrollable window to add that text to the thing
# this returns the expandButtons for each row, which we add
# to the buttonGroup
def setUpDelete(self):
x,y = self.SCREEN_SIZE
x-=100
viewAllWindow = ScrollableWindow(self.IMG_DIR, (x,y),self.SCREEN_SIZE, "recipeDeleter")
viewAllWindow.addText(self.dbm.getAllRecipes())
self.windowGroup.add(viewAllWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
def setUpViewGroceryList(self):
x,y = self.SCREEN_SIZE
x-=100
viewAllWindow = ScrollableWindow(self.IMG_DIR, (x,y),self.SCREEN_SIZE, "groceryListViewer")
self.windowGroup.add(viewAllWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
viewAllWindow.addGroceryList(self.groceryList.getAllIngredients())
writeDesktopButton = Button(self.IMG_DIR, "writeToDesktop", (705,80), "writeToDesktop", -1)
self.buttonGroup.add(writeDesktopButton)
def setUpRecipeAdder(self):
ingParser = IngredientParser()#self.dbm.loadParserDataFields())
recipeAdderWindow = RecipeReciever("addRecipePage",self.IMG_DIR, ingParser)
self.windowGroup.add(recipeAdderWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
"""def setUpSearch(self):
self.windowGroup.add(TextBox(
#def setUpSearchTextBox(self):"""
def doPaste(self):
if self.state == "addRecipe":
(self.windowGroup.sprites())[0].recieveClipboardPaste(pyperclip.paste())
def attemptScroll(self, dy):
for sprite in self.windowGroup.sprites():
sprite.scroll(dy)
def handleLeftMouseClick(self, xy):
for button in self.buttonGroup.sprites():
if button.getRect().collidepoint(xy):
## stupid organization leads to hacky solutions...
# in groceryList viewer, the writeToDesktop button must be stored in the main
# class. So thats whats going on here, we call writeToDesktop
# in the scrollable window and grab the grocery list there and send that to
# dbm to write it to desktop
if button.getIdentity() == "writeToDesktop":
theString = self.windowGroup.sprites()[0].writeToDesktop()
#print
#print
#print theString
self.dbm.writeStringToDesktop(self.windowGroup.sprites()[0].writeToDesktop(), "Grocery List")
self.state = "menu"
self.stateChanged = True
#print "got here!"
return
## we want to store the state of the stuff people are looking at
# whether that is a grocery list they have increased or recipes they have added to cart
# we call the "grabState()" method of the scrollableWindow to get the information
#### keep in mind, this is the previous state
# so if self.state == "browseAll" it means we are coming from browseAll state
# to the menu
if self.state == "browseAll":
## this one is tricky. We need to store a list of toggled rows, and then
# if the user goes back to the viewAllBrowser we need to call "updateState()"
# with this list, to ensure those buttons are toggled to reflect that they are
# still in the groceryList
# keep in mind this is a list of the names of the recipes that are already added
# so we will need to search for them in "updateState()"
allWindows = self.windowGroup.sprites()
if allWindows:
self.toggledRecipeNames = allWindows[0].grabState()
elif self.state == "viewGroceryList":
## this one is simple, we just grabState() and store the returns in self.groceryList
# all the changes the user has made will be in the new list
# and new changes will happen to that list
allWindows = self.windowGroup.sprites()
if allWindows:
self.groceryList.empty()
self.groceryList.addIngredientList(allWindows[0].grabState())
self.state = button.getIdentity()
self.stateChanged = True
command = None
if self.state == "browseAll" or self.state == "deleteRecipe":
for scrollableWindow in self.windowGroup.sprites():
if scrollableWindow.getRect().collidepoint(xy):
command = scrollableWindow.isClicked(xy)
break
if not command == None:
## command is a string, meaning there is a change of state
# from the button press
#print "command recieved!"
#print " ", command
if isinstance(command, str):
self.state = command
self.stateChanged = True
#print "this thing"
else:
if len(command) == 2:
#print "entered here"
#print "command[0]:", command[0]
if command[0] == "expand":
recipeInfo = self.dbm.loadRecipe(command[1]).toReadableString()
scrollableWindow.addTextBlock(command[1], recipeInfo)
elif command[0] == "addToGroceryList":
self.groceryList.addRecipe(self.dbm.loadRecipe(command[1]))
elif command[0] == "removeFromGroceryList":
self.groceryList.removeRecipe(self.dbm.loadRecipe(command[1]))
elif command[0] == "writeToDesktop":
#print "got into this"
self.dbm.writeRecipeToDesktop(command[1])
if command[0] == "delete":
#print "got here"
self.dbm.deleteRecipe(command[1])
elif self.state == "menu" or self.state=="prestart":
for sprite in self.buttonGroup.sprites():
if sprite.rect.collidepoint(xy):
parseID = sprite.getIdentity().split()
# no extra info, just an ID for the new state
# if this is not true there is something wrong
if len(parseID) == 1:
spriteID = parseID[0]
if not spriteID == self.state:
self.state = spriteID
self.stateChanged = True
else:
raise GUIError("button gives too much data")
elif self.state == "addRecipe":
for recipeReciever in self.windowGroup.sprites():
recipeData = recipeReciever.isClicked(xy)
if not recipeData == None:
#for k in recipeData.keys():
#print k, recipeData[k]
self.dbm.addRecipeToDataBase(Recipe.fromDictionary(recipeData))
self.state = "menu"
self.stateChanged = True
elif self.state == "viewGroceryList":
for scrollableWindow in self.windowGroup.sprites():
command = scrollableWindow.isClicked(xy)
elif self.state == "search":
## search has 2 states, the first is a text box where the user
# enters what the search ingredient is
# the second the window where the results are displayed
# we determine which state by what is in self.windowGroup.sprites()
# a TextBox is the first state, a ScrollableWindow is the second
for sprite in self.windowGroup.sprites():
pass#command = sprite.isClicked
def createMenu(self):
browseButton = Button(self.IMG_DIR, "textButton", (10,75), "browseAll", -1)
browseButton.addText("Browse All")
self.buttonGroup.add(browseButton)
#searchButton = Button(self.IMG_DIR, "textButton", (210,75), "search", -1)
#searchButton.addText("Search")
#self.buttonGroup.add(searchButton)
addRecipeButton = Button(self.IMG_DIR, "textButton", (410,75), "addRecipe", -1)
addRecipeButton.addText("Add Recipe")
self.buttonGroup.add(addRecipeButton)
deleteRecipeButton = Button(self.IMG_DIR, "textButton", (10,275), "deleteRecipe", -1)
deleteRecipeButton.addText("Delete Recipe")
self.buttonGroup.add(deleteRecipeButton)
groceryListButton = Button(self.IMG_DIR, "textButton", (210,275), "viewGroceryList", -1)
groceryListButton.addText("View Cart")
self.buttonGroup.add(groceryListButton)
exitButton = Button(self.IMG_DIR, "textButton", (410, 275), "exit", -1)
exitButton.addText("Exit")
self.buttonGroup.add(exitButton)
class Scoreboard():
#show score
def __init__(self, ai_settings, screen, stats):
#init properties
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
#show score font
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
#prepare init photo
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_level(self):
""""""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.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_high_score(self):
"""change hight_score to photo"""
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.bg_color)
#make the hight_score on the top
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_score(self):
"""make a photo to show score"""
rounded_score = round(self.stats.score, -1)
#score_str = str(self.stats.score)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
#riht upper
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
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.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
class Scoreboard():
"""显示得分信息的类"""
def __init__(self, ai_settings, screen, stats):
"""初始化属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
#字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
#准备四幅图像，方法作为属性，属性可在类的所有方法中使用
self.prep_images() #方法__init__缩短三行，若需要准备四幅图像，一行代码调用即可
def prep_images(self):
"""准备初始得分、最高得分、等级、飞船图像"""
self.prep_score(
) #若要准备一幅图像，实例.prep_score()即可，而不是 实例.prep_images().prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
"""显示还余下多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_level(self):
"""将等级图像转换为一幅渲染的图像"""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.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_high_score(self):
"""将最高得分转换为一幅渲染的图像"""
high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.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.screen_rect.top
def prep_score(self):
"""将得分转换为一幅渲染的图像"""
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(
score_str, True, self.text_color,
self.ai_settings.bg_color) ###self.score_image首次出现###
#将得分放在屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def show_score(self):
"""在屏幕上显示得分、等级、飞船"""
###self.score_image出现在不同方法中，只有作为属性才可以在类的所有方法中使用###
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)
class Scoreboard():
'''显示得分信息的类'''
def __init__(self, ai_settings, screen, stats):
'''初始化显示得分及属性'''
self.screen = screen
self.ai_settings = ai_settings
self.stats = stats
self.screen_rect = screen.get_rect()
#文字颜色字体
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 32)
#准备初始得分图像
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ship()
def prep_score(self):
'''将得分转为图像，并确定位置'''
rounded_score = int(round(self.stats.score, -1)) #将分数圆整
score_str = '{:,}'.format(rounded_score) #将得分数值转为字符串
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.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_str = '{:,}'.format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.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.screen_rect.top
def prep_level(self):
'''定义等级，将等级转为图像，确定位置'''
level = str(self.stats.level)
self.level_image = self.font.render(level, True, self.text_color,
self.ai_settings.bg_color)
self.level_rect = self.level_image.get_rect()
self.level_rect.top = self.score_rect.bottom + 10
self.level_rect.right = self.score_rect.right
def prep_ship(self):
'''定义飞船剩余生命数的飞船图像'''
self.ships = Group()
for ship_name in range(self.stats.ships_life):
ship = Ship(self.screen)
ship.rect.x = 10 + ship_name * ship.rect.width
ship.rect.y = 0
self.ships.add(ship)
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)
class Scoreboard:
"""A class to report scoring information."""
def __init__(self, ai_game):
"""Initialize scorekeeping attributes."""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for scoring information.
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score image.
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
# Bring in file path
self.fp = FilePaths()
self.record_high_filename = self.fp.record_high_score_path
def prep_score(self):
""" Turn the score into a rendered image."""
rounded_score = round(
self.stats.score, -1
) # round with -1 as second argument will round the value to neareset 10
score_str = "Score " + "{:,}".format(
rounded_score) # Add comma to numbers
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.bg_color)
# Display the score at the top right of the screen.
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20 # score is 20 pixel off right screen
self.score_rect.top = 20 # score is 20 below the top screen
def prep_high_score(self):
""" Turn the high score into a rendered image."""
high_score = round(
self.stats.high_score, -1
) # round with -1 as second argument will round the value to neareset 10
high_score_str = "High Score " + "{:,}".format(
high_score) # Add comma to numbers
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.bg_color)
# Center the high score at the top of the screen.
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx # set high score the center of screen
self.high_score_rect.top = self.score_rect.top # set the high score the same as scoreboard
def prep_level(self):
""" Turn the level into a render image."""
level_str = self.stats.level_name + str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.bg_color)
# Position the level below the score.
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 20
def prep_ships(self):
"""Show how many ships are left."""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def check_high_score(self):
"""Check to see if there is a new high score."""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
with open(self.record_high_filename, 'w') as fh:
fh.write(str(self.stats.high_score))
self.prep_high_score()
def show_score(self):
"""Draw score to the screen."""
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)
def draw(self, display) :
if(hasattr(self,'spritedict')):
Group.draw(self, display);
class Scoreboard():
def __init__(self, ai_settings, screen, stats):
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.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_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.bg_color)
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.right = 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.ai_settings.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):
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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)
class ScoreBoard:
"""显示得分信息的类"""
def __init__(self, ai_settings, screen, stats):
"""初始化得分属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# 显示得分时字体设置
self.text_color = (60, 60, 60)
self.text_size = 24
self.font = pygame.font.SysFont(None, self.text_size)
# 设置边距
self.bound_distance = 10
# 显示当前得分图像
self.prep_score()
# 显示最高得分图像
self.prep_high_score()
# 显示等级图像
self.prep_level()
# 显示剩余飞船数量
self.prep_ships()
def prep_score(self):
"""将得分转换为一幅图像"""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# 放在屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.right = \
self.screen_rect.right - self.text_size
self.score_rect.top = \
self.screen_rect.top + self.text_size / 2
def prep_high_score(self):
"""将最高分转换为图像"""
high_score = round(self.stats.high_score, -1)
high_score_str = "BEST: " + "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.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.screen_rect.top + self.text_size / 2
def prep_level(self):
"""将等级转换为图像"""
self.level_image = self.font.render("Level: " + str(self.stats.level),
True, self.text_color,
self.ai_settings.bg_color)
# 放在屏幕顶部中央
self.level_rect = self.level_image.get_rect()
self.level_rect.right = \
self.screen_rect.right - self.text_size
self.level_rect.top = \
self.score_rect.bottom + self.text_size / 2
def prep_ships(self):
"""显示剩余飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = self.bound_distance + ship_number * ship.rect.width
ship.rect.y = self.bound_distance
self.ships.add(ship)
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)
class App:
def __init__(self):
pygame.init()
pygame.mixer.init()
self._size = self._width, self._height = 800, 600
self._screen = pygame.display.set_mode(self._size)
rc.load_resources()
self._bg = pygame.transform.scale(rc.images['bg'], self._size)
self._key_states = pygame.key.get_pressed()
self._clock = pygame.time.Clock()
self._running = True
self._game_over = True
self._restart = True
pygame.mixer.music.play(loops=-1)
self._all_sprites = Group()
self._bonuses = Group()
self._bullets = Group()
self._mobs = Group()
self._player = Player((self._width / 2, self._height - 10), self._all_sprites, self._bullets)
self._all_sprites.add(self._player)
self._mob_count = 0
for i in range(self._mob_count):
self.create_mob()
# progress_bar = ProgressBar(10, 10, value=100, height=15)
# all_sprites.add(progress_bar)
self._player_health_bar = PlayerHealthProgressBar(self._player)
self._all_sprites.add(self._player_health_bar)
self._scoreBar = TextLabel((self._width / 2, 10))
self._all_sprites.add(self._scoreBar)
self._player_lives_bar = PlayerLivesProgressBar(self._size[0] - 10, 0, self._player)
self._all_sprites.add(self._player_lives_bar)
self._gun_power_progress_bar = GunPowerImageProgressBar(self._size[0] - 10, self._size[1] - 40, self._player)
self._all_sprites.add(self._gun_power_progress_bar)
@property
def restart(self):
return self._restart
# @restart.setter
# def restart(self, value):
# print('set restart')
# self._restart = value
# def init_sprites(self):
# self._all_sprites = Group()
# self._bonuses = Group()
# self._bullets = Group()
# self._mobs = Group()
# self._mob_count = 10
# self._player = Player((self._width / 2, self._height - 10), self._all_sprites, self._bullets)
# self._all_sprites.add(self._player)
#
# for i in range(self._mob_count):
# self.create_mob()
#
# # progress_bar = ProgressBar(10, 10, value=100, height=15)
# # all_sprites.add(progress_bar)
# self._player_health_bar = PlayerHealthProgressBar(self._player)
# self._all_sprites.add(self._player_health_bar)
#
# self._scoreBar = TextLabel((self._width / 2, 10))
# self._all_sprites.add(self._scoreBar)
#
# self._player_lives_bar = PlayerLivesProgressBar(self._size[0] - 10, 0, self._player)
#
# self._all_sprites.add(self._player_lives_bar)
#
# self._gun_power_progress_bar = GunPowerImageProgressBar(self._size[0] - 10, self._size[1] - 40, self._player)
#
# self._all_sprites.add(self._gun_power_progress_bar)
def _event_loop(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
print('quit')
self._running = False
self.restart = False
if event.type in (pygame.KEYUP, pygame.KEYDOWN):
self._key_states = pygame.key.get_pressed()
def create_mob(self):
Mob(self._size,
self._all_sprites, self._mobs)
def check_count_mob(self):
if len(self._mobs) < self._mob_count:
for i in range(self._mob_count - len(self._mobs)):
self.create_mob()
def start_screen(self):
start_labels = Group()
t1 = TextLabel((self._width / 2 - 50, 150), 'Star Wars')
t2 = TextLabel((self._width / 2 - 50, 250), 'arrows to control, space to fire')
# t3 = TextLabel((self._width / 2 - 50, 350), 'press LSHIFT key to start')
t4 = TextLabel((self._width / 2 - 50, 350), '1-easy, 2-normal, 3-hard')
start_labels.add(t1, t2, t4)
self._screen.blit(self._bg, self._bg.get_rect())
start_labels.draw(self._screen)
pygame.display.flip()
# waiting = True
for event in pygame.event.get():
if event.type == pygame.QUIT:
print('quit')
self._running = False
self.restart = False
# if event.type == pygame.KEYUP and event.key == pygame.K_LSHIFT:
# self._game_over = False
if event.type == pygame.KEYUP:
if event.key == pygame.K_1:
self._mob_count = 5
self._game_over = False
elif event.key == pygame.K_2:
self._mob_count = 15
self._game_over = False
elif event.key == pygame.K_3:
self._mob_count = 25
self._game_over = False
# init_and_run_app()
# self.init_sprites()
def check_collide_player_with_mobs_and_react(self):
hits = pygame.sprite.spritecollide(self._player, self._mobs, True, pygame.sprite.collide_circle)
for hit in hits:
self._player.on_damage(hit.radius)
if self._player.health <= 0:
# player_explosion_images = [rc.get_image(path.join('sonicExplosions', f'sonicExplosion0{i}.png')) for i
# in range(9)]
player_explosion = PlayerExplosion(self._player.rect.center)
self._all_sprites.add(player_explosion)
self._player.hide()
self._player.on_destroy()
explosion_size = hit.radius * 2
explosion = Explosion(hit.rect.center, explosion_size)
self._all_sprites.add(explosion)
def check_collide_bullets_with_mobs_and_react(self):
"""check collide bullets with mobs and react"""
hits = pygame.sprite.groupcollide(self._mobs, self._bullets, True, True)
for hit in hits:
self._scoreBar.text = int(self._scoreBar.text) + 50 - hit.radius
# self.create_mob()
hit.explosion_sound.play()
explosion_size = hit.radius * 2
# explosion_images = [rc.get_scaled_image(path.join('regularExplosions', f'regularExplosion0{i}.png'),
# (explosion_size, explosion_size)) for i in range(9)]
explosion = Explosion(hit.rect.center, explosion_size)
self._all_sprites.add(explosion)
if randint(1, 100) > 95:
bonus = Bonus(hit.rect.center, self._height)
self._all_sprites.add(bonus)
self._bonuses.add(bonus)
# def check(self):
# if self._game_over:
# self._game_over = False
# self.start_screen()
# self.init_sprites()
def update(self):
print(self._mob_count)
self._player.update2(self._key_states, self._size)
self.check_collide_player_with_mobs_and_react()
if self._player.hidden and pygame.time.get_ticks() - self._player.hide_time > 1000:
self._player.show()
if self._player.lives == 0:
self._running = False
# self._restart = False
# self._player.lives = 1
# self._game_over = True
# self._running = False
# restart_and_run_app()
# self._game_over = True
# init_and_run_app()
# self._game_over = True
# init_and_run_app()
self.check_collide_bullets_with_mobs_and_react()
hits3 = pygame.sprite.spritecollide(self._player, self._bonuses, True)
for hit in hits3:
self._player.on_catch_bonus(hit)
self.check_count_mob()
self._all_sprites.update()
def render(self):
self._screen.blit(self._bg, self._bg.get_rect())
self._all_sprites.draw(self._screen)
pygame.display.update()
def run_app(self):
while self._running:
# print(self._running)
self._clock.tick(30)
if self._game_over:
self.start_screen()
# init_and_run_app()
else:
self._event_loop()
self.update()
self.render()
class Scoreboard:
'''A class to report scoring information.'''
def __init__(self, ai_game):
'''Initialize scorekeeping attributes.'''
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for scoring information.
self.text_color = (247, 255, 0)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score images.
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
'''Turn the score into a rendered image.'''
rounded_score = round(self.stats.score, -1)
score_str = "S " + "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.bg_color)
# Display the score at the top right of the screen.
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):
'''Turn the high score into a rendered image'''
high_score = round(self.stats.high_score, -1)
high_score_str = "HS " + "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.bg_color)
#Center the high score at the top of the screen.
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):
'''Turn the level into a rendered image.'''
level_str = "L " + str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.bg_color)
# Position the level below the score.
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):
'''Show how many ship are left'''
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 1 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
'''Draw scores and level and ships to the screen.'''
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)
def check_high_score(self):
'''Check to see if there's a new high score.'''
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
with open(self.stats.filename, 'w') as f:
json.dump(self.stats.high_score, f)
class Scoreboard():
"""A class to report scoring information."""
def __init__(self, ai_settings, screen, stats):
"""Initialize scorekeeping attributes."""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Font settings for scoring information.
self.text_color = (220, 220, 220)
self.font = pygame.font.SysFont(None, 25)
# Prepare the initial score image.
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
"""Show how many ships are left."""
self.ships = Group()
for ship_number in range(self.stats.ship_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_high_score(self):
"""Turn the high score into a rendered image."""
high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(high_score)
high_score_str = "High Score: " + high_score_str
self.high_score_image = self.font.render(high_score_str, True,
self.text_color, self.ai_settings.bg_color)
# Center the high score at the top of the screen.
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_score(self):
"""Turn the score into a rendered image."""
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
score_str = "Score: " + score_str
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# Display the score at the top right of the screen.
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_level(self):
"""Turn the level into a rendered image."""
level_str = "Level: " + str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.ai_settings.bg_color)
# Position the level below the score.
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 show_score(self):
"""Draw score to the screen."""
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)
class Fallgame(Microgame):
def __init__(self):
Microgame.__init__(self)
self.ball=Ball()
self.ball1=Group(self.ball)
self.entities=Group()
self.Sound=pygame.mixer.Sound(join('games','fall','ball.wav'))
#self.entities=Group([self.fall])
self.timer=pygame.time.Clock()
self.time=0
# TODO: Initialization code here
def start(self):
# TODO: Startup code here
music.load(join('games','fall','fall.wav'))
music.play()
def stop(self):
# TODO: Clean-up code here
music.stop()
def update(self, events):
# TODO: Update code here
self.time+=self.timer.tick()
addg=Fall()
adgroup=Group(addg)
if self.time%1000<50:
self.entities.add(adgroup)
self.entities.update()
self.ball1.update()
collide=pygame.sprite.spritecollideany(self.ball,self.entities)
for event in events:
if event.type==KEYUP and event.key==K_q:
self.lose()
elif event.type ==KEYDOWN and event.key ==K_RIGHT:
self.ball.velocity=(30,0)
elif event.type==KEYUP and event.key==K_RIGHT:
self.ball.velocity=(0,0)
elif event.type==KEYDOWN and event.key==K_UP:
self.ball.velocity=(0,-30)
elif event.type==KEYUP and event.key==K_UP:
self.ball.velocity=(0,0)
elif event.type==KEYDOWN and event.key==K_DOWN:
self.ball.velocity=(0,30)
elif event.type==KEYUP and event.key==K_DOWN:
self.ball.velocity=(0,0)
elif event.type==KEYDOWN and event.key==K_LEFT:
self.ball.velocity=(-30,0)
elif event.type==KEYUP and event.key==K_LEFT:
self.ball.velocity=(0,0)
for event in events:
if event.type==KEYUP and (event.key==K_UP or event.key==K_RIGHT or event.key==K_LEFT or event.key==K_DOWN):
self.Sound.play()
_, y_bot = self.ball.rect.bottomleft
x_bot,_ = self.ball.rect.bottomright
if collide:
self.lose()
'''if self.ball.rect.y <=0 or y_bot >= locals.HEIGHT:
#self.lose()
for event in events:
if event.type ==KEYDOWN and event.key ==K_RIGHT:
self.ball.velocity=(0,0)
elif event.type==KEYUP and event.key ==K_RIGHT:
self.ball.velocity=(0,0)
elif event.type==KEYDOWN and event.key==K_LEFT:
self.ball.velocity=(0,0)
elif event.type==KEYUP and event.key==K_LEFT:
self.ball.velocity=(0,0)
elif self.ball.rect.x<=0 or x_bot>= locals.WIDTH:
#self.lose()
for event in events:
if event.type==KEYDOWN and event.key==K_UP:
self.ball.velocity=(0,0)
elif event.type==KEYUP and event.key==K_UP:
self.ball.velocity=(0,0)
elif event.type==KEYDOWN and event.key==K_DOWN:
self.ball.velocity=(0,0)
elif event.type==KEYUP and event.key==K_DOWN:
self.ball.velocity=(0,0)'''
# TODO: Rendering code here
def render(self, surface):
surface.blit(background,(0,0))
self.ball1.draw(surface)
self.entities.draw(surface)
def get_timelimit(self):
# TODO: Return the time limit of this game (in seconds, 0 <= s <= 15)
return 20
class Scoreboard():
def __init__(self,screen,ai_settings,stats):
"""initialize scoreboard attribute"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# setting scoreboard font
self.text_color = (30,30,30)
self.font = pygame.font.SysFont(None,48)
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
"""show left ship on up right corner of screen"""
self.ships = Group()
for ship_num in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = ship.rect.width * ship_num + 10
ship.rect.y = 10
self.ships.add(ship)
def prep_level(self):
"""render the level as image"""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color, self.ai_settings.bg_color)
# show level on screen under the score
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10
def prep_score(self):
round_score = int(round(self.stats.score,-1))
score_str = "{:,}".format(round_score)
self.score_image = self.font.render(score_str,True,self.text_color,self.ai_settings.bg_color)
# show score at up right corner of screen
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def show_score(self):
"""show score on screen"""
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)
def prep_high_score(self):
"""render the highest score as image"""
high_score = int(round(self.stats.high_score,-1))
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str,True,
self.text_color,self.ai_settings.bg_color)
# set the highest score on the center of the screen
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.screen_rect.top
for e in event.get():
if e.type == QUIT:
done = True
elif e.type == KEYDOWN:
if e.key == K_ESCAPE:
done = True
elif e.unicode == u'r':
generation = randint(0,500)
index = randint(0,10000)
while not personat(generation, index):
index += 1
describeperson(generation, index)
elif e.type == MOUSEBUTTONDOWN and e.button == 1:
for sprite in sprites:
if sprite.rect.collidepoint(e.pos) and sprite.exists:
generation = sprite.rect.left / 8
index = sprite.rect.top / 8
describeperson(generation, index)
break
sprites.update()
sprites.clear(screen, background)
sprites.draw(screen)
display.flip()
limit.tick(20)
class ScoreBoard:
"""显示得分信息的类"""
def __init__(self, ai_game):
"""初始化显示得分涉及的属性"""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 24)
# 准备初始得分、等级和飞船图像
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""将得分转换为一副渲染的图像"""
rounded_score = round(self.stats.score, -1) # 舍入到10的整数倍
score_str = "current score: " + "{:,}".format(
rounded_score) # 将数值转换为字符串时，在其中插入逗号（千位分隔符）
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.bg_color)
# 在屏幕右上角显示得分
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 10
self.score_rect.top = 10
def prep_high_score(self):
"""将最高得分转换为渲染的图像"""
rounded_high_score = round(self.stats.high_score, -1)
high_score_str = "highest score: " + "{:,}".format(rounded_high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.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):
"""将等级转换为渲染的图像"""
level_str = "level: " + str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.bg_color)
# 将等级放在得分下方
self.level_rect = self.level_image.get_rect()
self.level_rect.top = self.score_rect.bottom + 5
self.level_rect.right = self.score_rect.right
def prep_ships(self):
"""显示还余下多少飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score_level_ships(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)
def check_high_score(self):
"""检查是否诞生了新的最高得分"""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
class Scoreboard:
"""Класс для вывода игровой информации."""
def __init__(self, ai_game):
"""Инициализирует атрибуты подсчёта очков."""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Настройки шрифта для вывода счёта.
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Подготовка исходного изображения
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
"""Сообщает количество оставшихся кораблей."""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_level(self):
"""Преобразует уровень в графическое изображение"""
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.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_score(self):
"""Преобразует текущий счёт в графическое изображение."""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.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 = round(self.stats.high_score, -1)
high_score_str = '{:,}'.format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.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 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)
def check_high_score(self):
"""Проверяет, появился ли новый рекорд."""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
class Gameboard(object):
'''
classdocs
'''
def __init__(self, surface, width, height, song_filename):
'''
Constructor
'''
#progressively increase; must end with 1
self.PROB_HEALTH = 0.4
self.PROB_KI = 0.7
self.PROB_SHIELD = 0.9
self.PROB_SWORD = 1.0
self.windowSurface = surface
self.width = width
self.height = height
self.song_filename = song_filename
board_size = (width, height)
self.gameSurface = Surface(board_size) # This will be drawn every frame to the window
song_file = open(song_filename)
self.song_name = song_file.readline().strip()
self.song_length = float(song_file.readline())
self.pixels_per_second = float(song_file.readline())
self.level_filename = song_file.readline().strip()
self.music_filename = song_file.readline().strip()
self.background_filename = song_file.readline().strip()
self.pixel_offset = 0
self.last_frame_time = -1
self.frac_scroll = 0
# print "{0}[{1}] : {2}".format(self.song_name, self.song_length, self.pixels_per_second)
# self.background_width = (self.pixels_per_second * self.song_length) + width
self.background_width = width + 96 # Jank scroll edition!
background_size = (self.background_width, height)
self.backgroundSurface = Surface(background_size)
self.__render_background()
self.backgroundSurface.set_colorkey((0,0,0),pygame.RLEACCEL)
#self.backgroundSurface.set_colorkey((217,62,245),pygame.RLEACCEL)
#self.backgroundSurface.set_alpha(100,pygame.RLEACCEL)
self.mainScreenBackground,self.mainScreenBackgroundRect = load_image_from_folder('backgrounds', self.background_filename)
#self.backgroundSurface.blit(mainScreenBackground, (0,0))
#self.__render_background()
possible_samurai_positions = []
for i in range(0, 6):
possible_samurai_positions.append(PATH_HEIGHT * i + 15)
self.samurai = Samurai(possible_samurai_positions)
self.samurai_sprite_group = Group(self.samurai)
self.bridge_group = OrderedUpdates()
self.mine_group = OrderedUpdates()
self.enemy_group = OrderedUpdates()
self.attack_group = OrderedUpdates()
self.healthpack_group = OrderedUpdates()
self.ki_potion_group = OrderedUpdates()
self.shield_group = OrderedUpdates()
self.sword_group = OrderedUpdates()
self.explosion_group = OrderedUpdates()
# tempSprite = self.samurai_sprite_group.sprites()
# tempRect = tempSprite[0].get_rect()
# self.testSword = VerticalSlash(tempRect.centerx,tempRect.centery, self.remove_attack)
# self.attack_group.add(self.testSword)
if sys.platform == "win32":
# On Windows, the best timer is time.clock()
self.default_timer = time.clock
else:
# On most other platforms, the best timer is time.time()
self.default_timer = time.time
def draw(self):
self.gameSurface.fill((0,0,0))
#self.gameSurface.fill((217,62,245))
origin = (0, 0)
# this_scroll = 0
self.scroll_amount = 0
if self.last_frame_time > 0:
cur_time = self.default_timer()
self.gap_time = cur_time - self.last_frame_time
# print "Pixels per second: {0}\nGap Time: {1}\nScrollAmount: {2}".format(self.pixels_per_second, self.gap_time, this_scroll)
self.last_frame_time = cur_time
else:
self.gap_time = 0
self.last_frame_time = self.default_timer()
this_scroll = self.pixels_per_second * self.gap_time
self.frac_scroll += this_scroll
if self.frac_scroll >= 1:
self.scroll_amount = math.floor(self.frac_scroll)
self.pixel_offset += self.scroll_amount
# print "Now scrolling {0} pixel(s)".format(whole_part)
self.frac_scroll -= self.scroll_amount
if self.pixel_offset > 96:
self.pixel_offset = self.pixel_offset - 96
if self.pixel_offset < 0:
self.pixel_offset = 0
self.gameSurface.blit(self.mainScreenBackground, origin)
window_rect = Rect(self.pixel_offset, 0, self.gameSurface.get_width(), self.gameSurface.get_height())
# print window_rect
self.gameSurface.blit(self.backgroundSurface, origin, window_rect)
#All other drawing
self.bridge_group.update(self.scroll_amount)
self.bridge_group.draw(self.gameSurface)
self.mine_group.update(self.scroll_amount)
self.mine_group.draw(self.gameSurface)
self.enemy_group.update(self.scroll_amount)
self.enemy_group.draw(self.gameSurface)
self.samurai_sprite_group.update()
self.samurai_sprite_group.draw(self.gameSurface)
self.healthpack_group.update(self.scroll_amount)
self.healthpack_group.draw(self.gameSurface)
self.ki_potion_group.update(self.scroll_amount)
self.ki_potion_group.draw(self.gameSurface)
self.shield_group.update(self.scroll_amount)
self.shield_group.draw(self.gameSurface)
self.sword_group.update(self.scroll_amount)
self.sword_group.draw(self.gameSurface)
#self.testSword = VerticalSlash(400,400)
#self.attack_group.add(self.testSword)
self.attack_group.update()
self.attack_group.draw(self.gameSurface)
self.explosion_group.update()
self.explosion_group.draw(self.gameSurface)
# self.testSword.draw(self.gameSurface)
for bridge in self.bridge_group.sprites():
if bridge.rect.left < 0:
self.bridge_group.remove(bridge)
#Annnnd blast it back to the screen
window_origin = (0, 60)
self.windowSurface.blit(self.gameSurface, window_origin)
def add_bridge(self, bridge_num):
# print "FAKE BRIDGE"
new_bridge = Bridge(1101, bridge_num * PATH_HEIGHT + 39)
self.bridge_group.add(new_bridge)
def add_mine(self, string_num):
# print "CREATE ZE LANDMINE"
new_mine = Mine(1101, PATH_HEIGHT * string_num + 42)
self.mine_group.add(new_mine)
def add_powerup(self, string_num):
r = random.random()
if r < self.PROB_HEALTH:
self.add_healthpack(string_num)
elif r < self.PROB_KI:
self.add_kiboost(string_num)
elif r < self.PROB_SHIELD:
self.add_shield(string_num)
elif r < self.PROB_SWORD:
self.add_sword(string_num)
def add_healthpack(self, string_num):
# print "such a healthy young man!"
new_healthpack = Healthpack(1101, PATH_HEIGHT * string_num + 42)
self.healthpack_group.add(new_healthpack)
def add_shield(self, string_num):
new_shield = Shield(1101, PATH_HEIGHT * string_num + 42)
self.shield_group.add(new_shield)
def add_sword(self, string_num):
new_sword = MegaSword(1101, PATH_HEIGHT * string_num + 42)
self.sword_group.add(new_sword)
def add_kiboost(self, string_num):
new_ki_potion = KiPotion(1101, PATH_HEIGHT * string_num + 42)
self.ki_potion_group.add(new_ki_potion)
def add_enemy(self, string_num):
new_enemy = Enemy(1111, PATH_HEIGHT * string_num + 42)
self.enemy_group.add(new_enemy)
def add_male_groupie(self, string_num):
new_enemy = MaleGroupie(1111, PATH_HEIGHT * string_num + 15)
self.enemy_group.add(new_enemy)
def add_lawyer(self, string_num):
new_lawyer = Lawyer(1111, PATH_HEIGHT * string_num + 15)
self.enemy_group.add(new_lawyer)
def add_bodyguard(self, string_num):
new_bodyguard = Bodyguard(1111, PATH_HEIGHT * string_num + 15)
self.enemy_group.add(new_bodyguard)
def remove_attack(self, attack):
self.attack_group.remove(attack)
def add_attack(self, attack):
self.attack_group.add(attack)
def add_explosion(self, y_val):
new_explosion = Explosion(20, y_val, self.explosion_group)
def __render_background(self):
# Jank implementation that just uses that one sprite over and over again!
# Jay's jank dirtBlockThingy is 96x48 pixels
num_blocks = int(math.ceil(self.background_width / 96.0))
cur_width = 0
for bI in range(0, num_blocks):
for hI in range(0, 6):
my_location = (cur_width, (PATH_HEIGHT * hI + 35))
dp = DirtPath(my_location)
# print "DirtPath at {0}".format(my_location)
self.backgroundSurface.blit(dp.image, my_location)
cur_width += 96
class Scoreboard():
def __init__(self, game, sound):
self.game = game
self.screen = game.screen
self.screen_rect = game.screen.get_rect()
self.settings = game.settings
self.stats = game.stats
self.sound = sound
self.text_color = (0, 230, 230)
self.font = pg.font.SysFont(None, 40)
self.score_image, self.score_rect = None, None
self.high_score_image, self.high_score_rect = None, None
self.level_image, self.level_rect = None, None
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.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 check_high_score(self, score):
if score > self.stats.high_score:
self.stats.high_score = score
self.prep_high_score()
def prep_high_score(self):
rounded_score = int(round(self.stats.high_score, -1))
score_str = "{:,}".format(rounded_score)
self.high_score_image = self.font.render(score_str, True,
self.text_color,
self.settings.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.settings.bg_color)
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
self.ships = Group()
for i in range(self.stats.ships_left):
ship = Ship(game=self.game, sound=self.sound)
ship.rect.x = 10 + i * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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)
def main():
# start up pygame
pg.init()
# create clock for time keeping
clock = pg.time.Clock()
# create pygame window
screen = pg.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pg.display.set_caption("animated sprite demo")
# initialize animated sprite
animated_sprites = Group()
animated_sprite = AnimatedSprite(
animated_sprites,
#image_sequences = NINJA_ANIMATIONS,
#image_sequences = WALK_ANIMATIONS,
image_sequences=STICK_ANIMATIONS,
pos=(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2
) # put sprite in center of window
)
# initialize quit event
quit_event = False
# main game loop
while True:
# handle events
events = pg.event.get()
for event in events:
if event.type == pg.QUIT:
quit_event = True
elif event.type == pg.KEYDOWN and event.key == pg.K_SPACE:
animated_sprite.set_status(
PUNCHING) # start punching animation in controlled way
animated_sprite.vel.x = 0 # set positioning attribute - pnching makes you stop
if quit_event == True:
break
# if sprite is not punching (has highest priority), check for other keyobard input
if animated_sprite.status != PUNCHING:
# handle keys pressed
keys_pressed = pg.key.get_pressed()
if keys_pressed[pg.K_RIGHT] and not keys_pressed[pg.K_LEFT]:
animated_sprite.set_status(
WALKING) # start walking right animation in controlled way
animated_sprite.direction = RIGHT # set animation attribute
animated_sprite.vel.x = VEL_X # set positioning attribute
elif keys_pressed[pg.K_LEFT] and not keys_pressed[pg.K_RIGHT]:
# move left
if animated_sprite.status != WALKING:
animated_sprite.set_status(
WALKING
) # start walking left animation in controlled way
animated_sprite.direction = LEFT # set animation attribute
animated_sprite.vel.x = -VEL_X # set positioning attribute
elif (keys_pressed[pg.K_LEFT] and keys_pressed[pg.K_RIGHT]) or (
not keys_pressed[pg.K_LEFT]
and not keys_pressed[pg.K_RIGHT]):
animated_sprite.set_status(
STANDING) # set standing animation in a controlled way
animated_sprite.vel.x = 0 # set positioning attribute
# update sprite
animated_sprites.update()
# draw sprite
screen.fill(WHITE)
animated_sprites.draw(screen)
# flip canvas
pg.display.flip()
# control speed
clock.tick(CLOCK_SPEED)
# quit animation demo
pg.quit()
sys.exit()
def run_game():
global ch,dobollet,db,wea,t
pygame.init()
pygame.mixer.init()
shoot = mixer.Sound("C:\windows\media\Ring02.wav")
music = mixer.Sound("sounds/Windows Critical Stop.wav")
image = pygame.image.load('bg.gif')
turn = 0
ch = 10
fg = 1
pfg = 1
joysticks = [pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())]
print(len(joysticks))
for joystick in joysticks:
joystick.init()
i = 0
j = False
sit = False
sco = 0
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()
ships = Group()
blocks = Group()
aliens = Group()
l = 0
r = 0
godown = 0
sb = Scoreboard(ai_settings,screen,0,sco)
alies = Group()
alien = Alien(ai_settings,screen,ship,0,1)
buttons = Group()
eateat = Alien(ai_settings,screen,ship,ship,ship)
aliens.add(eateat)
liberint = 'liberint.txt'
do_liberint(pygame,Block,blocks,ai_settings,screen,liberint)
yu = False
#rint(ship.y)iii
alienbullets = Group()
ert = 0
tr = [1,1,1,1,0,0,0,0,1,1,1,1,2,0,0,0,0,1,1,1,1,0,0,1,1,1,1,2,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,2,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,1,1,2]
sty = Group()
uii = 0
poweraps = Group()
#do_liberint(ship,Block,aliens,blocks,Alien_what_go_up_and_down,ai_settings,screen,tr,Alien_what_go_up_and_down,poweraps,poweraps)
aiens = Group()
ant = Ant_men(ai_settings,screen,ship)
ships.add(ship)
# shoot.play(-1)
time = 0
un = 0
while True:
sb.show_score()
rand = randint(-1000,1000)
if j == True and i == 0:
ert = 0
# ship.y -= 1*pfg
for alien in blocks.sprites():
alien.y += pfg
alien.rect.y = alien.y
#for alien in poweraps.sprites():
ant.y += pfg
ant.rect.y = ant.y
fg += 1*pfg
#print(ship.y)
# ship.rect.y = ship.y
if fg == 250:
pfg*=-1
if fg == 0:
i = 0
pfg*=-1
j = False
scr = screen.get_rect()
if j == False and godown == 0:
for alien in blocks.sprites():
alien.y -= 1
alien.rect.y = alien.y
ant.y-=1 # #updatenow = 1
for alien in aliens.sprites():
alien.x -= 1
alien.rect.x = alien.x
if r == 0:
ship.image = pygame.image.load('SCRightUp.gif')
ship.blitme()
#pygame.display.flip()
for alien in blocks.sprites():
alien.x -= 1
alien.rect.x = alien.x
#pygame.display.flip()
#pygame.display.flip()
#pygame.display.flip()
ship.image = pygame.image.load('SCright.gif')
ship.blitme()
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if l == 0:
ship.image = pygame.image.load('SCleftup.gif')
#pygame.display.flip()
for alien in blocks.sprites():
alien.x += 1
alien.rect.x = alien.x
#pygame.display.flip()
#pygame.display.flip()
#pygame.display.flip()
#ship.blitme()
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if r == 0:
ant.x -= 1
ant.rect.x = ant.x
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if l == 0:
ant.x += 1
ant.rect.x = ant.x # if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
for event in pygame.event.get():
#for event in pygame.event.get():
# # if event.type == pygame.KEYDOWN:
# if event.key == pygame.K_1:
# first = randint(0,220)
# second = randint(0,220)
# three = randint(0,220)
# ai_settings.bg_color = (first,second,three)
# if event.key == pygame.K_b:
# sys.exit()
# if event.key == pygame.K_RIGHT:
# #ship.movin_right = True
# cr = 0
# t = 2
# if event.key == pygame.K_LEFT:
# #ship.movin_left = True
# cl = 0
# t = 3
# if event.key == pygame.K_r:
# #ship.movin_left = True
# if len(bullets) <= bulets:
# new_bullet = Bullet(ai_settings,screen,ship,aliens,bullets,0)
# bullets.add(new_bullet)
# if event.key == pygame.K_UP:
# cu = 0
# t = 0
if event.type == pygame.JOYAXISMOTION:
buttons = joystick.get_numaxes()
for i in range(buttons):
but = joystick.get_axis(0)
if but < -.5:
ship.x -= 1
ship.rect.x = ship.x
if pygame.sprite.spritecollideany(ship,blocks):
ship.x += fuster
ship.rect.x = ship.x
t = 3
but = joystick.get_axis(0)
if but > .5:
ship.x += 1
ship.rect.x = ship.x
if pygame.sprite.spritecollideany(ship,blocks):
ship.x -= fuster
ship.rect.x = ship.x
t = 2
but = joystick.get_axis(1)
if but < -.5:
j = True
# but = joystick.get_axis(1)
# if but < -.5:
# ship.y -= 1
# ship.rect.y = ship.y
# if pygame.sprite.spritecollideany(ship,blocks):
# ship.y += fuster
# ship.rect.y = ship.y
# t = 0
# but = joystick.get_axis(1)
# if but > .5:
# ship.y += 1
# ship.rect.y = ship.y
# if pygame.sprite.spritecollideany(ship,blocks):
# ship.y -= fuster
# ship.rect.y = ship.y
# t = 1
if event.type == pygame.JOYHATMOTION:
buttons = joystick.get_numhats()
for i in range(buttons):
but = joystick.get_hat(i)
if but == (-1,0):
l = 0
r = 1
cu = 1
cd = 1
t = 3
but = joystick.get_hat(i)
if but == (1,0):
l = 1
r = 0
cu = 1
cd = 1
t = 2
but = joystick.get_hat(i)
if but == (0,1):
j = True
but = joystick.get_hat(i)
if event.type == pygame.JOYBUTTONDOWN:
buts = joystick.get_numbuttons()
# print(button)
#pass
for buto in range(buts):
but = joystick.get_button(1)
if but:
music.play()
new_bullet = Bullet(ai_settings,screen,ship,aliens,bullets,alien,t)
bullets.add(new_bullet)
break
but = joystick.get_button(2)
if but:
print(3)
if t == 2:
for xui in blocks:
xui.rect.x-= 50
xui.x-= 50
for xui in aliens:
xui.rect.x-= 50
xui.x-= 50
if t == 3:
for xui in blocks:
xui.rect.x+= 50
xui.x+= 50
for xui in aliens:
xui.rect.x+= 50
xui.x+= 50
break
elif event.type == pygame.JOYBUTTONUP:
#buttons = joystick.get_numbuttons()
button = joystick.get_button(False)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
l = 0
r = 1
cu = 1
cd = 1
t = 3
if event.key == pygame.K_RIGHT:
l = 1
r = 0
cu = 1
cd = 1
t = 2
#but = joystick.get_hat(i)
if event.key == pygame.K_DOWN:
l = 1
r = 1
cu = 1
cd = 0
t = 1
#but = joystick.get_hat(i)
if event.key == pygame.K_UP:
l = 1
r = 1
cu = 0
cd = 1
t = 0
# elif event.type == pygame.KEYUP:
# if event.key == pygame.K_RIGHT:
# ship.movin_right = False
# cr = 1
# if event.key == pygame.K_LEFT:
# ship.movin_left = False
# cl = 1
# if event.key == pygame.K_UP:
# cu = 1
# if event.key == pygame.K_DOWN:
# cd = 1
# if event.key == pygame.K_2:
# ship.image = pygame.image.load(random.choice(images))
# if event.key == pygame.K_DOWN:
# ship.movin_down = False
# #276
#276
ship.update(blocks,ship)
bullets.update(bullets,aliens)
collisions = pygame.sprite.groupcollide(bullets,aliens,True,True)
#print('you lose')
#break
ship.blitme()
if pygame.sprite.spritecollideany(ship,blocks):
for alien in blocks.sprites():
alien.y += 1
alien.rect.y = alien.y
ant.y += 1
ant.rect.y = ant.y
# godown = 0
# pygame.display.flip()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0 or bullet.rect.bottom >= 900 or bullet.rect.centerx <= 0 or bullet.rect.centerx >= 1000:
bullets.remove(bullet)
screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.copy():
# if bullet.rect.bottom >= 900:
# bullets.remove(bul
# screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.sprites():
# bullet.draw_bullet()
# first = randint(0,200)
# second = randint(0,200)
# three = randint(0,200)
# ai_settings.bullet_color = (first,second,three)
# collisins = pygame.sprite.groupcollide(blocks,bullets,True,True)
collisions = pygame.sprite.groupcollide(ships,poweraps,False,True)
# for alien in aliens.sprites():
# if pygame.sprite.spritecollideany(alien,blocks):
# alien.duraction *= -1
for bullet in bullets.sprites():
bullet.draw_bullet()
collisions = pygame.sprite.groupcollide(bullets,aliens,True,True)
if collisions:
moneys+=1
collisions = pygame.sprite.groupcollide(bullets,blocks,True,False)
first = randint(0,200)
second = randint(0,200)
three = randint(0,200)
ai_settings.bullet_color = (first,second,three)
bullets.update(bullets,aliens)
ship.blitme()
#chekupdown_fleet_edges(ai_settings,aliens)
#alien.blitme()
bullets.draw(screen)
sb.show_score()
alienbullets.update(bullets,aliens)
aliens.draw(screen)
#if un == 0:
blocks.draw(screen)
blocks.update()
if pygame.sprite.spritecollideany(ant,ships):
if pfg == -1:
g = 1
ant.image = pygame.image.load('bowserflat.gif')
bullets.empty()
if ch <= 0:
print('you win')
break
un = 1
j = False
pfg *=-1
j = True
else:
if un == 0:
print('you lose')
sys.exit()
if pygame.sprite.spritecollideany(ant,bullets):
ch -= 1
bullets.empty()
if ch <= 0:
print('you win')
break
#if bezero == 34:
#bezero = 0
#sb.show_score()
#poweraps.draw(screen)
ant.blitme()
if un == 0:
ant.update()
#pygame.display.update()
#screen.blit(image,(0,0))
if l == 0:
ship.image = pygame.image.load('SCleft.gif')
pygame.display.flip()
ship.blitme()
if r == 0:
ship.image = pygame.image.load('SCright.gif')
pygame.display.flip()
ship.blitme()
aliens.draw(screen)
aliens.update()
# for alien in aliens.sprites():
# if pygame.sprite.spritecollideany(alien,blocks):
# alien.duraction *= -1
pygame.display.flip()
def main():
global font
global message
pygame.init()
pygame.display.set_caption("Lunar Lander Re-Created By Matthew Jones And Philip Jones")
screen = pygame.display.set_mode((800,600))
font = pygame.font.SysFont('Calibri', 25, True, False)
lander = Lander()
lander_group = Group()
lander_group.add(lander)
burn = Burn(lander)
burn_group = Group()
burn_group.add(burn)
fuel_bar_front = Rectangle(blue)
fuel_bar_front_group = Group()
fuel_bar_front_group.add(fuel_bar_front)
fuel_bar_back = Rectangle(white)
fuel_bar_back_group = Group()
fuel_bar_back_group.add(fuel_bar_back)
planet = Planet()
planet_group = Group()
planet_group.add(planet)
done = False
pygame.display.update()
flicker = True
music = False
first_frame = True
landed_ok = None
while not done:
thrust = False
left = False
right = False
pygame.event.pump()
keys=pygame.key.get_pressed()
if keys[K_ESCAPE]:
done = True
if landed_ok is None:
if keys[K_SPACE] or keys[K_UP]:
thrust = True
if keys[K_LEFT]:
left = True
if keys[K_RIGHT]:
right = True
landed = False
if first_frame:
first_frame = False
else:
offset_x, offset_y = (planet.rect.left - lander.rect.left), (planet.rect.top - lander.rect.top)
landed = lander.mask.overlap(planet.mask, (offset_x, offset_y)) != None
status = lander.calculate_vertical_speed(thrust, landed)
if landed and landed_ok is None:
landed_ok = status
if landed_ok:
landed_message()
else:
crashed_message()
if not landed and lander.height < 200:
if lander.delta_vert < -2:
message = "Almost there! TOO FAST!"
else:
message = "Almost there! Slow down for a soft landing"
lander.calc_horizontal(left, right)
screen.fill(background_colour)
lander.render()
lander_group.draw(screen)
if not landed and thrust and lander.is_fuel_remaining():
flicker = not flicker
image_number = 1 if flicker else 0
burn.render(image_number)
burn_group.draw(screen)
if not music:
play_sound('../sounds/rocket_sound.mp3', True)
music = True
elif music and not landed:
music = False
pygame.mixer.music.stop()
#draw fuel bar :)
percent_fuel = float(lander.fuel) / float(Lander.max_fuel) * 100.0
fuel_bar_back.render(10, 10, 104, 12)
fuel_bar_back_group.draw(screen)
fuel_bar_front.render(12, 12, percent_fuel, 8)
fuel_bar_front_group.draw(screen)
planet.render()
planet_group.draw(screen)
display_message(screen)
pygame.display.update()
time.sleep(0.015)
class Scoreboard():
"""Класс для вывода игровой информации"""
def __init__(self, ai_settings, screen, stats, life_ship_url):
"""Инициализирует артибуты подсчета очков"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Настройка шрифта для вывода счета
self.text_color = (255, 255, 255)
self.font = pygame.font.SysFont(None, 48)
# Подготовка исходного изображения
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships(life_ship_url)
def prep_ships(self, life_ship_url):
"""Сообщает количество оставшихся кораблей"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Life_Ship(self.screen, life_ship_url)
ship.rect.x = 20 + ship_number * (ship.rect.width * 2)
ship.rect.y = 1
self.ships.add(ship)
def prep_level(self):
"""Преобразует уровень в графическое изображение"""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.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 + 5
def prep_score(self):
"""Преобразует текущий счет в графическое изображение"""
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# Вывод счета в правой верхней части экрана
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 5
def prep_high_score(self):
"""Преобразует рекордный счет в графическое изображение"""
high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.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 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)
if evt.type == QUIT:
exit()
elif evt.type == KEYDOWN:
if evt.key == K_ESCAPE:
exit()
if evt.key == K_SPACE:
game = True
begin = False
pygame.display.flip()
clock.tick(FPS)
# create sidebar stuff
doEvent.draw_sidebar()
sidebar_stuff.draw(screen)
health.draw()
score.draw()
while game: # main game loop
pygame.draw.rect(screen, BLACK, screen_rect)
# input for exit
for evt in pygame.event.get():
if evt.type == QUIT:
exit()
elif evt.type == KEYDOWN:
if evt.key == K_ESCAPE:
pygame.key.set_repeat()
pause = True
class Scoreboard():
''' Uma classe para mostrar informações sobre pontuação. '''
def __init__(self, ai_settings, screen, stats):
''' Inicializa os atributos da pontuação. '''
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Configurações de fonte para as inforemções de pontuação.
self.text_color = (255, 0, 0) # Cor do texto.
self.font = pygame.font.SysFont(None, 48) # Instanciamos para a fonte.
# Prepara a imagem da pontuação inicial.
self.prep_score()
# Prepara a imagem da pontuação máxima.
self.prep_high_score()
# Prepara a imagem do nível do jogo.
self.prep_level()
# Cria um grupo de espaçonaves para indicar aos jogadores o número de espaçonaves restantes.
self.prep_ships()
def prep_ships(self):
''' Mostra quantas espaçonaves restam. '''
self.ships = Group(
) # Cria um grupo vazio para armazenar instâncias das espaçonaves.
for ship_number in range(
self.stats.ships_left
): # Percorre todas as espaçonaves que restam ao jogador.
ship = Ship(self.ai_settings,
self.screen) # Cria uma nova espaçonave.
ship.rect.x = 10 + ship_number * ship.rect.width # Faz as espaçonaves aparecerem uma ao lado da outra, com uma margem de 10 pixels do lado esquerdo do grupo de espaçonaves.
ship.rect.y = 10 # 10 pixels abaixo da parte superior da tela para que as espaçonaves estejam alinhadas com a imagem da pontuação.
self.ships.add(
ship) # Adiciona cada nova espaçonave ao grupo ships.
def prep_level(self):
''' Transforma o nível em uma imagem renderizada. '''
self.level_image = self.font.render(
str(self.stats.level), True, self.text_color,
self.ai_settings.bg_color) # Cria a imagem.
# Posiona o nível abaixo da pontuação.
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right # Define o atributo right da imagem para que seja igual ao atributo right da pontuação.
self.level_rect.top = self.score_rect.bottom + 10
''' O atributo top é definido a 10 pixels abaixo da parte inferior da imagem da pontuação
de modo a deixar um espaço entre a pontuação e o nível. '''
def prep_high_score(self):
''' Transforma a pontuação máxima em uma imagem renderizada. '''
high_score = int(
round(self.stats.high_score, -1)
) # Diz a python para arrendondar o valor de stats.score para o multíplo mais próximo de 10.
high_score_str = "{:,}".format(
high_score
) # Tranforma o valor númerico em uma string e a formatamos com vírgulas para render.
self.high_score_image = self.font.render(
high_score_str, True, self.text_color, self.ai_settings.bg_color
) # Gera uma imagem com a pontuação máxima.
# Centraliza a pontuação máxima na parte superior da tela.
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_score(self):
''' Transforma a pontuação em uma imagem renderizada. '''
rounded_score = int(
round(self.stats.score, -1)
) # Diz a python para arrendondar o valor de stats.score para o multíplo mais próximo de 10.
score_str = "{:,}".format(
rounded_score
) # Tranforma o valor númerico em uma string e a formatamos com vírgulas para render.
self.score_image = self.font.render(
score_str, True, self.text_color,
self.ai_settings.bg_color) # Transforma em uma imagem.
# Exibe a pontuação na parte supetrior direito da tela.
self.score_rect = self.score_image.get_rect(
) # Garante que a pontuação sempre seja alinhada com o lado direito.
self.score_rect.right = self.screen_rect.right - 20 # Define a borda direita da pontuação a 20 pixels da borda direita da tela.
self.score_rect.top = 20 # Posiciona a borda superior da pontuação 20 pixels abaixo da parte superior da tela.
def show_score(self):
''' Exibe a imagem rendereizada da pontuação. '''
self.screen.blit(self.score_image, self.score_rect)
''' Esse método desenha a imagem da pontuação na tela no local especificado por score_rect. '''
self.screen.blit(self.high_score_image, self.high_score_rect)
''' Desenha a pontuação máxima na parte superior central da tela. '''
self.screen.blit(self.level_image, self.level_rect)
''' Adiciona uma linha para desenhar a imagem do nível do jogo na tela. '''
self.ships.draw(self.screen)
''' Desenha as espaçonaves que restam ao jogador. '''
class Game(Application):
def __init__(self):
Application.__init__(self)
self.screenRect = self.screen.get_rect()
self.minDt = 200
self.enemyGroup = Group()
self.enemyGroup.add(BasicEnemy(100,100,0,1,self.screenRect,80))
self.bulletGroup = Group()
self.player = Player(self.screenRect)
self.playerGroup = GroupSingle(self.player)
self.playerWeaponType = 1
self.playerFired = False
self.playerMoveX = 0
self.playerMoveY = 0
self.playerMoveFlag = False
def handle_event(self,event):
if event.type == MOUSEBUTTONUP and event.button == 1:
self.playerFired = True
if event.type == KEYDOWN:
## need to put in KEYUP to turn off the thing...
if event.key == K_DOWN:
self.playerMoveY = 1
self.playerMoveFlag = True
if event.key == K_UP:
self.playerMoveY = -1
self.playerMoveFlag = True
if event.key == K_LEFT:
self.playerMoveX = -1
self.playerMoveFlag = True
if event.key == K_RIGHT:
self.playerMoveX = 1
self.playerMoveFlag = True
if event.key == K_SPACE:
self.playerFired = True
if event.type == KEYUP:
if event.key == K_DOWN:
self.playerMoveY = 0
self.playerMoveFlag = True
if event.key == K_UP:
self.playerMoveY = 0
self.playerMoveFlag = True
if event.key == K_LEFT:
self.playerMoveX = 0
self.playerMoveFlag = True
if event.key == K_RIGHT:
self.playerMoveX = 0
self.playerMoveFlag = True
def update(self, screen):
dt = min(self.minDt, self.clock.get_time())
self.enemyGroup.update(dt)
if self.playerFired:
self.bulletGroup.add(self.player.shoot(self.playerWeaponType))
self.playerFired = False
## need to validate holding down the key...
if self.playerMoveFlag:
self.player.setDirection(self.playerMoveX, self.playerMoveY)
self.playerMoveFlag = False
self.bulletGroup.update(dt)
self.playerGroup.update(dt)
pygame.sprite.groupcollide(self.enemyGroup, self.bulletGroup, True, True)
def draw(self,screen):
screen.fill((0,0,0))
self.playerGroup.draw(screen)
self.enemyGroup.draw(screen)
self.bulletGroup.draw(screen)
class Scoreboard():
"""A class to report scoring information."""
def __init__(self, ai_settings, screen, stats):
"""Initialize scorekeeping attributes."""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""Turn the score into a rendered image."""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.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):
"""Turn the high score into a rendered image."""
high_score = round(self.stats.high_score, -1)
score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(score_str, True,
self.text_color, self.ai_settings.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):
"""Turn the level into a rendered image."""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color, self.ai_settings.bg_color)
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
"""Show how many ships are left."""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
"""Draw score to the screen."""
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)
#Draw ships
self.ships.draw(self.screen)
class Scoreboard(object):
"""显示得分信息的类"""
def __init__(self, ai_settings, screen, stats):
"""初始化显示得分涉及的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont("Times New Roman", 32)
self.prep_images()
def prep_images(self):
"""准备包含得分和飞船数量的初始图像"""
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""将得分转换为渲染的图像"""
rounded_score = int(round(self.stats.score, -1)) # -1表示圆整到10倍
score_str = "{:,}".format(rounded_score) # 在数字间插入逗号， 如1,000,000
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# 将得分放在屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.left = self.screen_rect.left + 10
self.score_rect.top = 10
def prep_high_score(self):
"""将最高得分转换为渲染的图像"""
high_score = int(round(self.stats.high_score, -1))
high_score_str = ("High Score: " + "{:,}").format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color, self.ai_settings.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.ai_settings.bg_color)
# 将等级放在得分下方
self.level_rect = self.level_image.get_rect()
self.level_rect.left = self.score_rect.left
self.level_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
"""显示还余下多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.right = (self.screen_rect.right - 10 -
ship_number * ship.rect.width)
ship.rect.top = 10
self.ships.add(ship)
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)
class Scoreboard:
"""得点の情報をレポートするクラス"""
def __init__(self, ai_game):
"""得点を記録するための属性を初期化する"""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# 得点表示用のフォントを設定する
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# 初期の得点画像を準備する
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""得点を描画用の画像に変換する"""
rounded_score = round(self.stats.score, -1)
score_str = "Score: " + "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.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 = round(self.stats.high_score, -1)
high_score_str = "High score: " + "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.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):
"""レベルを描画用の画像に変換する"""
level_str = "Level " + str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.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):
"""宇宙船の残数を表示する"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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)
def check_high_score(self):
"""新しいハイスコアかをチェックし、必要であれば表示を更新する"""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
class Scoreboard(object):
"""A class to report scoring information."""
def __init__(self,ai_settings,screen,stats):
"""Initialize scorekeeping attributes."""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Font settings for scoring information
self.text_color = (30,30,30)
self.font = pygame.font.SysFont(None,24)
# Prepare the initial score images
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""Turn the score into a rendered image."""
rounded_score = int(round(self.stats.score,-1))
score_str = "Score - " + "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str,True,self.text_color,
self.ai_settings.bg_color)
# Display the score at the top right of the screen
self.score_rect = self.score_image.get_rect()
self.score_rect.centerx = self.screen_rect.centerx
self.score_rect.top = 22
def prep_high_score(self):
"""Turn the high score into a rendered image."""
high_score = int(round(self.stats.high_score,-1))
high_score_str = "High Score - " + "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str,True,
self.text_color,self.ai_settings.bg_color)
# Center the high score at the top of the screen
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = 0
def prep_level(self):
"""Turn the level into a rendered image."""
self.level_image = self.font.render("Level - " + str(self.stats.level),
True,self.text_color,self.ai_settings.bg_color)
# Position the level below the score
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.top
def prep_ships(self):
"""Show how many ships are left."""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings,self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
"""Draw score and ships to the screen."""
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)
# Draw ships
self.ships.draw(self.screen)
class Scoreboard():
###A class to report scoring information.###
def __init__(self, ai_settings, screen, stats):
###Initialize scorekeeping attributes.###
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Schriftart für die Anzeige des Punktestandes.
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Richtet den Anfangsstand für den Punktestand ein.
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
###Turn the score into a rendered image.###
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# Zeigt den Punktestand oben rechts auf dem Bildschirm an.
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):
###Turn the high score into a rendered image.###
high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.bg_color)
# Zentriert die Highscoreanzeige am oberen Bildschirmrand.
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):
###Turn the level into a rendered image.###
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.bg_color)
# Platziert das Level unter dem Punktestand.
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):
###Show how many ships are left.###
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
###Draw score to the screen.###
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)
class PongMicrogame(Microgame):
'''
Simple Pong Microgame.
An example Microgame. Single bounce Pong.
Attributes:
rect - the bounding box of the playfield
ball - the ball of the microgame
lbat - the left-hand bat of this microgame, ai-controlled
rbat - the right-hand bat of this microgame, user-controlled
sprites - the sprite group that contains the sprites of the game
timeSinceWin - the time in (ms) when the player won the game, or 0 if the
game has not been won yet
'''
def __init__(self):
Microgame.__init__(self)
self.rect = Rect(0, 0, locals.WIDTH, locals.HEIGHT)
speed = BALL_SPEED_BASE
widthqrt = self.rect.width / 4
heightqrt = self.rect.height / 4
self.ball = Ball(self, 150, randint(heightqrt, heightqrt * 3), \
randint(speed, speed + BALL_SPEED_RANGE), \
choice([speed, -speed]))
self.lbat = Bat(100, randint(heightqrt, heightqrt * 3), \
self.rect, self.ball, True)
self.rbat = Bat(self.rect.width - 150, \
randint(heightqrt, heightqrt * 3), \
self.rect, self.ball)
self.sprites = Group((self.ball, self.lbat, self.rbat))
self.timeSinceWin = 0
def start_win_countdown(self):
'''
Starts the successful hit countdown --- once this is up, the player wins
the game.
'''
self.timeSinceWin = pygame.time.get_ticks()
def start(self):
music.load('games/pong/music.mp3')
music.play(0, 0.5)
def stop(self):
music.stop()
def update(self, events):
time = pygame.time.get_ticks()
if self.timeSinceWin > 0 and \
time > self.timeSinceWin + TIME_TO_WIN_AFTER_BOUNCE:
self.win()
self.sprites.update()
for event in events:
if event.type == KEYDOWN:
if event.key == K_UP:
self.rbat.direction = -1
elif event.key == K_DOWN:
self.rbat.direction = 1
if event.type == KEYUP:
if event.key == K_UP or event.key == K_DOWN:
self.rbat.direction = 0
def render(self, surface):
surface.fill(Color(0, 0, 0))
self.sprites.draw(surface)
def get_timelimit(self):
return 10
class Scoreboard(object):
"""docstring for Scoreboard"""
def __init__(self, ai_settings, screen, stats):
self.ai_settings = ai_settings
self.screen = screen
self.stats = stats
self.screen_rect = screen.get_rect()
#字体设置
self.font = pygame.font.SysFont(None, 48)
self.text_color = (30, 30, 30)
#文本转成图像显示
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
'''得分转换成图像 '''
#格式化得分（圆整，使最后一位永远为0）
rounded_score = int(round(self.stats.score, -1))
score_str ="{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.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):
'''最高分转换成图像 '''
#格式化得分（圆整，使最后一位永远为0）
high_score = int(round(self.stats.high_score, -1))
high_score_str ="{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True, self.text_color,
self.ai_settings.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.ai_settings.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):
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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)
