def _draw_cloud(tag_list, surface, vertical=True, fontname='fonts/Arial.ttf', fontzoom=5, rectangular=False):
#Sort the tags by size and wordlength
tag_list.sort(key=lambda tag: len(tag['tag']))
tag_list.sort(key=lambda tag: tag['size'])
tag_list.reverse()
if rectangular:
spiral = _rectangular_spiral
else:
spiral = _archimedean_spiral
sizeRect = surface.get_rect()
tag_store = Group()
for tag in tag_list:
rot = 0
if vertical and randint(0, 2) == 0:
rot = 90
currentTag = Tag(tag, (0, 0), rot, fontname=fontname, fontzoom=fontzoom)
xpos = sizeRect.width - currentTag.rect.width
if xpos < 0: xpos = 0
xpos = randint(int(xpos * LOWER_START) , int(xpos * UPPER_START))
currentTag.rect.x = xpos
ypos = sizeRect.height - currentTag.rect.height
if ypos < 0: ypos = 0
ypos = randint(int(ypos * LOWER_START), int(ypos * UPPER_START))
currentTag.rect.y = ypos
_search_place(currentTag, tag_store, sizeRect, spiral, vertical)
tag_store.add(currentTag)
surface.blit(currentTag.image, currentTag.rect)
return tag_store
def __init__(self, moving_sprite,
speedx = 0,
maxspeedx = -1,
speedy = 0,
maxspeedy = -1,
posx = 0,
posy = 0,
thrust_strength = 0,
accelx = 0,
accely = 0,
gravity = 1000,
decrease_speed_ratio = 2.0):
Group.__init__(self)
self.moving_sprite = moving_sprite
self.speedx = speedx
self.speedy = speedy
self.maxspeedx = maxspeedx
self.maxspeedy = maxspeedy
self.posx = posx
self.posy = posy
self.thrust_strength = thrust_strength
self.accelx = accelx
self.accely = accely
self.gravity = gravity
self.decrease_speed_ratio = decrease_speed_ratio
self.bumping_walls = []
def touches(self, group):
touching = Group()
coll = self.rect.inflate(2,1) # grow 1px to allow for edges
for sprite in group:
if coll.colliderect(sprite.rect):
touching.add(sprite)
return touching
def run_game():
pygame.init()
ai_settings = Settings()
""" Screen settings and such"""
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
stats = GameStats(ai_settings)
bg_color = (230, 230, 230)
"""background screen color; grey"""
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
while True:
gf.check_events(ai_settings, screen, ship, bullets)
ship.update()
gf.update_bullets(ai_settings, screen, ship, aliens, bullets)
gf.update_aliens(ai_settings, stats, screen, ship, aliens, bullets)
gf.update_screen(ai_settings, screen, ship, aliens, bullets)
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
def __init__(self, bounds):
Group.__init__(self)
self.bounds = bounds
self.spawn_rate = COIN_SPAWN_RATE * 1000
self.spawn_timer = 0
def update(self, dt):
Group.update(self, dt)
self.spawn_timer += dt
if self.spawn_timer >= self.spawn_rate:
self.spawn()
self.spawn_timer = 0
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)
def __init__ ( self, color, initial_position, size, player = None ):
"""Creates a new ViewManager object."""
#Sprite
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface(size)
self.image.fill(color)
self.rect = self.image.get_rect()
self.rect.topleft = initial_position
#Drawable objects
if (player == None):
self.player = Character()
else: self.player = player
#Draw starting objects
#self.setup()
#Sprite Groups
self.activeObjects = Group()
self.activeBackground = Group()
self.activeAvatar = pygame.sprite.GroupSingle()
#Collision
self.collision = CollisionManager()
def _create_image(self):
grp = Group()
for word in self.words:
if len(grp.sprites()) == 0:
word.scale(self.ratio+0.2)
pm_w = word.rect.width
pm_h = word.rect.height
pm_x, pm_y = place_primary(pm_w, pm_h)
word.rect.x, word.rect.y = pm_x, pm_y
arch_x = pm_x + pm_w/2
arch_y = pm_y + pm_h/2
else:
word.scale(self.ratio)
for x, y in archimedean_spiral(False):
if self.debug:
rs = Surface((5, 5))
rs.fill((0, 0, 255))
rs.set_alpha(100)
self.sf.blit(rs, (x + arch_x, y + arch_y))
word.set_position(x + arch_x, y + arch_y)
x_out = CANVAS_WIDTH - CANVAS_PADDING < word.rect.x + word.rect.width or word.rect.x < CANVAS_PADDING
y_out = CANVAS_HEIGHT - CANVAS_PADDING < word.rect.y + word.rect.height or word.rect.y < CANVAS_PADDING
out_of_bound = x_out or y_out
if spritecollideany(word, grp, collide_mask) is None and not out_of_bound:
if self.debug:
rs = Surface((5, 5))
rs.fill((0, 255, 0))
rs.set_alpha(100)
self.sf.blit(rs, (x + arch_x, y + arch_y))
break
self.sf.blit(word.image, word.rect)
grp.add(word)
class Player (Sprite):
size = 20,20
color = 255,255,0
shottimer = 0
def __init__(self, loc, bounds):
Sprite.__init__(self) # required for sprites
self.image = Surface(self.size)
self.rect = self.image.get_rect()
self.rect.center = loc
self.bounds = bounds # passes the bounds to the object so it can be saved.
self.image.fill(self.color)
self.bullets = Group()
def update(self):
if self.shottimer > 0:
self.shottimer -= 1
self.rect.center = pygame.mouse.get_pos()
self.rect.clamp_ip(self.bounds) #makes sure it doesn't go outside the provided rectangle
def shoot(self):
if not self.alive(): #return just stops everything in hte function
return
if self.shottimer == 0:
bullet = Bullet(self.bounds)
self.bullets.add(bullet) #adds the new bullet to the Bullets list
bullet.rect.midbottom = self.rect.midtop
self.shottimer = 10
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 load_tiles(self, filename):
try:
self.tiles = Group()
self.walls = Group()
level = open(filename, 'r')
line = level.readline().strip()
while line != '[tiles]':
line = level.readline().strip()
self.sheet = int(level.readline().strip())
set_tile_stats(self)
self.set_areas()
y = -self.tile_height
line = level.readline().strip()
while line and line != '[units]':
x = 0
y += self.tile_height
for k in line.split(' '):
if not k.strip():
continue
tile = Tile(x, y, self.sheet, int(k), self)
self.tiles.add(tile)
if tile.kind in self.wall_kinds:
tile.flags |= FLAGS.WALL
self.walls.add(tile)
else:
tile.flags |= FLAGS.FLOOR
x += self.tile_width
line = level.readline().strip()
self.lw = x
self.lh = y + self.tile_height
level.close()
except IOError:
return self.load_default_tiles()
def load_default_tiles(self, columns=40, rows=30, sheet=0,
kinds=(0, 1, 2)):
self.sheet = sheet
set_tile_stats(self)
self.set_areas()
self.lw = columns * self.tile_width
self.lh = rows * self.tile_height
self.tiles = Group()
self.walls = Group()
y = 0
t = 0
for r in xrange(rows):
x = 0
for c in xrange(columns):
tile = Tile(x, y, sheet, kinds[t % len(kinds)], self)
self.tiles.add(tile)
if tile.kind in self.wall_kinds:
tile.flags |= FLAGS.WALL
self.walls.add(tile)
else:
tile.flags |= FLAGS.FLOOR
x += self.tile_width
t += 1
y += self.tile_height
def __init__(self):
#setup
pygame.init()
pygame.font.init()
self.font = pygame.font.Font(None,24)
self.fontColor = (0,0,0)
pygame.mixer.init()
pygame.display.set_mode(SCREEN)
pygame.display.set_caption('#ElJuegoDeLasJoincic')
self.screen = pygame.display.get_surface()
self._quit=False
self.clock = pygame.time.Clock()
self.controller= Controller()
self.background = load_image("background.png")
self.menu_background = load_image("menu_background.png")
self.menu_iniciar = load_image("menu_iniciar.png")
self.menu_salir = load_image("menu_salir.png")
self.gameover = load_image("gameover.png")
self.cursor = load_image("cursor.png")
self.arrow = load_image("arrow.png")
self.player = Player()
self.group = Group()
self.protocolo = Protocolo()
self.group.add(self.player)
self.groupOyentes = Group()
self.groupTakitos = Group()
self.groupHUD = Group()
self.state= GAME_INIT
class Level(object):
_map = {
"%": "flower",
"~": "grass",
".": "path"
}
def __init__(self, name, tilesheet):
# load level data
path = os.path.join(DATA_DIR, "levels", name) + ".lvl"
with open(path, "r") as f:
data = f.read().strip().split("\n")
# parse level data
data = [ [ self._map.get(c) for c in row ] for row in data ]
# build the level
self.tiles, size = tilesheet.build(data)
self.bounds = Rect((0,0), size)
# find path
self.path = Group()
for tile in self.tiles:
if tile.type == "path":
self.path.add(tile)
# render
self.render_background()
def render_background(self):
self.background = Surface(self.bounds.size)
self.tiles.draw(self.background)
def __init__(self):
Microgame.__init__(self)
self.character_select = True
self.player1_selector = Player1_Selector()
self.player2_selector = Player2_Selector()
self.falco = Falco_Selector()
self.fox = Fox_Selector()
self.samus = Samus_Selector()
self.snake = Snake_Selector()
self.pit = Pit_Selector()
self.mewtwo = Mewtwo_Selector()
self.zelda = Zelda_Selector()
self.character_possibilities = Group(self.falco, self.fox, self.samus, self.snake, self.pit, self.mewtwo, self.zelda)
self.sprites = OrderedUpdates(self.falco, self.fox, self.samus, self.snake, self.pit, self.mewtwo, self.zelda, self.player1_selector, self.player2_selector)
self.player1 = Fox()
self.player2 = Falco()
self.p1victory = pygame.image.load(join('games', 'ssb', 'p1_win.png'))
self.p2victory = pygame.image.load(join('games', 'ssb', 'p2_win.png'))
self.platform = Final_Destination()
self.p1win = False
self.p2win = False
self.wincondition = False
self.a_track = False
self.d_track = False
self.lshift_track = False
self.quote_track = False
self.l_track = False
self.rshift_track = False
self.playergroup = Group(self.player1, self.player2)
self.player1_projectiles = Group()
self.player2_projectiles = Group()
def build_wave(self):
"""Creates the rectangular formation of enemies
Enemy sprites are stored in the inherited Group and the instance formation
"""
# build the formation and store in a 2d array indexed col, row
self.formation = []
for current_col in range(0, self.cols):
col_list = []
for current_row in range(0, self.rows):
new_enemy = Enemy(self.window_size, self.sprite_filename, self.speed, current_col, current_row)
left_pos = current_col * (self.gap + new_enemy.rect.width) + self.gap
top_pos = current_row * (self.gap + new_enemy.rect.height) + self.gap
new_enemy.rect = new_enemy.image.get_rect(left=left_pos, top=top_pos)
col_list.append(new_enemy)
Group.add(self, new_enemy)
self.formation.append(col_list)
self.leftmost_col = 0 # the left- and rightmost cols with living enemies
self.rightmost_col = self.cols - 1
self.move_delay_step = 0 # counts the frames between moves
self.shoot_delay_step = 0 # counts the frames between shots
self.current_vector = EAST # the wave always starts by moving right
class Player(Sprite):
color = 255, 255, 0
size = 20, 20
def __init__(self, loc, bounds):
Sprite.__init__(self)
self.image = Surface(self.size)
self.rect = self.image.get_rect()
self.rect.center = loc
self.bounds = bounds
self.image.fill(self.color)
self.bullets = Group()
def update(self):
self.rect.center = pygame.mouse.get_pos()
self.rect.clamp_ip(self.bounds)
def shoot(self):
if not self.alive():
return
bullet = Bullet(self.bounds)
bullet.rect.midbottom = self.rect.midtop
self.bullets.add(bullet)
class Player(Sprite):
color = 255,25,69
size = 20,20
def __init__(self, loc, bounds):
Sprite.__init__(self) #makes player a sprite object
self.image = Surface(self.size)
self.rect = self.image.get_rect()
self.rect.center = loc
self.bounds = bounds
self.image.fill(self.color)
self.bullets = Group()
def update(self):
self.rect.center = pygame.mouse.get_pos() #player moves/stays with mouse
self.rect.clamp_ip(self.bounds) #cant leave screen bounds
def shoot(self):
if not self.alive():
return #stop doing anything in this function
bullet = Bullet(self.bounds)
bullet.rect.midbottom = self.rect.midtop
self.bullets.add(bullet)
def _draw_cloud(
tag_list,
surface,
layout=LAYOUT_MIX,
fontname=DEFAULT_FONT,
palette=DEFAULT_PALETTE,
fontzoom=5,
rectangular=False,
order=True):
#Sort the tags by size and word length
tag_list.sort(key=lambda tag: len(tag['tag']))
tag_list.sort(key=lambda tag: tag['size'])
tag_list.reverse()
if rectangular:
spiral = _rectangular_spiral
else:
spiral = _archimedean_spiral
sizeRect = surface.get_rect()
tag_store = Group()
if not order:
random.shuffle(tag_list)
for tag in tag_list:
rot = 0
flip = False
if layout == LAYOUT_MIX and randint(0, 2) == 0:
rot = 90
elif layout == LAYOUT_VERTICAL:
rot = 90
elif layout == LAYOUT_MOST_VERTICAL:
rot = 90
flip = True
elif layout == LAYOUT_MOST_HORIZONTAL:
flip = True
#set color if tag has no color
if not hasattr(tag, 'color'):
pass
currentTag = Tag(tag, (0, 0), rot, fontname=fontname, fontzoom=fontzoom)
xpos = sizeRect.width - currentTag.rect.width
if xpos < 0: xpos = 0
xpos = randint(int(xpos * LOWER_START) , int(xpos * UPPER_START))
currentTag.rect.x = xpos
ypos = sizeRect.height - currentTag.rect.height
if ypos < 0: ypos = 0
ypos = randint(int(ypos * LOWER_START), int(ypos * UPPER_START))
currentTag.rect.y = ypos
_search_place(currentTag, tag_store, sizeRect, spiral, flip)
tag_store.add(currentTag)
surface.blit(currentTag.image, currentTag.rect)
return tag_store
def update(self):
"""Updates cells' positions only if target is followable"""
if self.target.is_followable():
Group.update(self)
if self.delay > 0:
self.delay -= 1
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
def remove(self, *sprites):
for current_sprite in sprites:
if current_sprite not in self: continue
row, col = self.get_cell_row_col(current_sprite)
self.cells[row][col] = None
Group.remove(self, *sprites)
def __init__(self, loc, bounds):
# Call parent's constructor
pygame.sprite.Sprite.__init__(self)
# Player PNG
sprite_sheet = SpriteSheet("p1_gunwalk.png")
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(64, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(128, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(192, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(256, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(320, 0, 64, 78)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(640, 0, 64, 78)
self.walking_frames_r.append(image)
# Load all the right facing images, then flip them
# to face left.
image = sprite_sheet.get_image(0, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(64, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(128, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(192, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(256, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(320, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(640, 0, 64, 78)
image = pygame.transform.flip(image, True, False)
self.walking_frames_l.append(image)
# Set the image the player starts with
self.image = self.walking_frames_r[0]
# Reference the image rect.
self.rect = self.image.get_rect()
self.rect.center = loc
self.bounds = bounds
self.bullets = Group()
self.bulletcasings = Group()
def __init__(self, config, screen):
"""Initialize the sprite list."""
self.config = config
self.screen = screen
#initialize the sprites
self.wiz = Wizard(config, self)
self.monsters = Group()
self.missiles = Group()
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)
def __init__(self, map, imageCache, rectPixelView, imWidth, imHeight):
Group.__init__(self)
self._changeListeners = []
self.map = map
self.worldRect = Rect(0, 0, self.map.width * imWidth, self.map.height * imHeight)
self.imageCache = imageCache
self.imageSize = (imWidth, imHeight)
self.offsetX = 0
self.offsetY = 0
self.setView(rectPixelView)
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()
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
def __init__(self, map, imageCache, rectPixelView, imWidth, imHeight):
Group.__init__(self)
self._changeListeners = []
self.upperLeft = [0, 0]
self.numTiles = (int(rectPixelView.width / imWidth), int(rectPixelView.height / imHeight))
self.map = map
self.imageCache = imageCache
self.imageSize = (imWidth, imHeight)
self.offsetX = 0
self.offsetY = 0
self.setView(rectPixelView)
# Start Music
pygame.mixer.music.load("Sounds/theme.mp3")
# Make the Play button.
play_button = Button(ai_settings, screen, "Play")
# Make the High Scores button.
score_button = HighScoreButton(ai_settings, screen, "High Scores")
# Create an instance to store game statistics and create a scoreboard.
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Make a ship, a group of bullets, and a group of aliens.
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
# Time
clock = pygame.time.Clock()
fps = 120
# images for title
alien1Img = pygame.image.load('Images/Alien1-1.png')
alien2Img = pygame.image.load('Images/Alien2-1.png')
alien3Img = pygame.image.load('Images/Alien3-1.png')
def alien_pics(image, x1, y1):
screen.blit(image, (x1, y1))
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 = (230, 230, 230)
self.font = pygame.font.SysFont(None, 48)
self.prep_score()
self.prep_highscore()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""Turn score into 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.settings.bg_colour)
# Display score at top right 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 prep_highscore(self):
rounded_highscore = round(self.stats.highscore)
highscore_str = "{:,}".format(rounded_highscore)
self.highscore_image = self.font.render(highscore_str, True,
self.text_color,
self.settings.bg_colour)
self.highscore_rect = self.highscore_image.get_rect()
self.highscore_rect.centerx = self.screen_rect.centerx
self.highscore_rect.top = self.score_rect.top
def show_score(self):
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.highscore_image, self.highscore_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
def check_highscore(self):
if self.stats.score > self.stats.highscore:
self.stats.highscore = self.stats.score
self.prep_highscore()
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_colour)
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.image = pygame.transform.scale(ship.image, (30, 60))
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def run_game():
#initialise and create the screen object
pygame.init()
gs = Settings()
screen = pygame.display.set_mode((gs.screen_width, gs.screen_heigh))
pygame.display.set_caption("Invaders Must Die")
#play some music
print(gs.musicName)
print(gs.musicPath)
#pygame.mixer.init
#pygame.mixer.music.load(gs.musicPath)
#pygame.mixer.music.play(-1)
#Create sounds object
sounds = gameSounds(gs.musicPath, gs.endGameMusic, gs.laserSoundsPath)
#sounds.playBgMusic()
#Create the Rocket
rocket = Rocket(screen, gs)
#group for the bullets
bullets = Group()
#Create an ALien
alien = Alien(screen, gs)
#create a group for the aliens
aliens = Group()
#create fleet
funcs.create_fleet(aliens, gs, screen, rocket)
#set up game stats
stats = GameStats(gs)
#create play button
play_button = Button(gs, screen, "Play Game", gs.green_button)
#create play button
game_over = Button(gs, screen, "Game Over", gs.red_button)
#Create a Scoreboard
SB = Scoreboard(gs, screen, stats)
#control the frame rate of the game
clock = pygame.time.Clock()
FRAMERATE = 150
#start the main loop of the program
while True:
#clock.tick(FRAMERATE)
funcs.check_events(rocket, screen, bullets, gs, play_button, stats, SB,
aliens, screen, sounds)
if stats.game_active == True:
rocket.update_position()
#check if the bullets have gone off the screen
funcs.update_bullets(bullets, aliens, screen, rocket, gs, stats,
SB)
#print(len(bullets))
funcs.update_aliens(aliens, gs, rocket, bullets, screen, stats, SB,
sounds)
funcs.update_screen(screen, rocket, gs, bullets, aliens, play_button,
stats, game_over, SB)
def run_game():
global bullets_die
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()
alienbullets = Group()
stats = GameStats(ai_settings)
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)
alien.y = -90
alien.rect.y = alien.y
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
# print(alien.rect.y)
create_alien(ai_settings, screen, aliens, alien_number, row_number)
# aliens.add(alien)
bg_color = (20, 250, 200)
while True:
# print(alien.rect.y)
# tre = randint(-1000,1000)
# if tre == 1:
# alien.y = 0
# create_alien(ai_settings,screen,aliens,alien_number,row_number)
# if tre >= 990:
# bullets_die = False
# for row_number in range(number_rows):
# for alien_number in range(number_aliens_x):
# # print(alien.rect.y)
# create_alien(ai_se
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if ship.rect.collidepoint(mouse_x, mouse_y):
ship.image = pygame.image.load(choice(images))
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
bullets.update()
ship.update()
aliens.update()
ship.blitme()
ship.update()
aliens.draw(screen)
pygame.display.flip()
def run_game():
global bullets_die
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()
ships = Group()
#ships.add(ship)
bg_color = (20, 250, 200)
while True:
pygame.mouse.set_visible(True)
# print(alien.rect.y)
# tre = randint(-1000,1000)
# if tre == 1:
# alien.y = 0
# create_alien(ai_settings,screen,aliens,alien_number,row_number)
# if tre >= 990:
# bullets_die = False
# for row_number in range(number_rows):
# for alien_number in range(number_aliens_x):
# # print(alien.rect.y)
# create_alien(ai_settings,screen,aliens,alien_number,row_number)
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:
print("IOU")
for alien in ships.sprites():
new_bullet = Bullet(ai_settings, screen, alien, 0, 0)
bullets.add(new_bullet)
print(len(ships))
print(len(bullets))
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
elif event.type == pygame.MOUSEBUTTONDOWN:
turtle = 0
mouse_x, mouse_y = pygame.mouse.get_pos()
ship = Ship(ai_settings, screen, mouse_x, mouse_y)
ships.add(ship)
for alien in ships.sprites():
if alien.rect.collidepoint(mouse_x, mouse_y):
new_bullet = Bullet(ai_settings, screen, alien,
mouse_x, mouse_y)
bullets.add(new_bullet)
turtle = 1
if turtle == 1:
#shi[]
ship = Ship(ai_settings, screen, mouse_x, mouse_y)
ships.add(ship)
ships.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()
chek_fleet_edges(ai_settings, aliens)
aliens.update()
for bullet in ships.sprites():
bullet.blitme()
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
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 = (30, 30, 30)
self.font = pygame.font.SysFont(None, 30)
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 = "{:,}pt".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):
""" """
rounded_high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}pt".format(rounded_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 = str(self.stats.level)
self.level_image = self.font.render(level_str, 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.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 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 MainScene(game.Scene):
def __init__(self, manager):
game.Scene.__init__(self, manager)
self.group_labels = Group()
self.group_buttons = Group()
self.ui_events = game.UI_Events()
self.font = pygame.font.Font(None, 28)
position = self.state.manager.rect.right - 20, 20
self.label = game.Label("Press A Button", self.font, game.color.snow,
position, "topright")
y = itertools.count(20, 32)
rect = pygame.Rect(20, 0, 150, 30)
for letter in "ABC":
name = "Button " + letter
rect.y = next(y)
self.create_button(name, rect.copy(), self.push_button,
"You push " + name)
x = 20
y = itertools.count(200, 40)
red_toggle = self.create_toggle_button("red", (x, next(y)),
self.toggle_color)
self.create_toggle_button("lawngreen", (x, next(y)), self.toggle_color)
self.create_toggle_button("dodgerblue", (x, next(y)),
self.toggle_color)
red_toggle.set_toggle()
self.toggle = red_toggle
self.toggle_surface = pygame.Surface((400, 120))
self.toggle_surface.fill(game.color.red)
def create_button(self, text, rect, callback, user_data):
button = game.Button(text, self.font, game.color.snow, rect, callback,
user_data)
renderer = game.Renderer(button, game.color.dodgerblue * 0.75,
game.color.dodgerblue,
game.color.dodgerblue * 0.5,
self.group_buttons)
self.ui_events.add(button)
def create_toggle_button(self, text, position, callback):
rect = pygame.Rect(0, 0, 30, 30)
foreground = pygame.Surface(rect.size, pygame.SRCALPHA)
foreground.fill((0, 0, 0, 0))
hover = foreground.copy()
toggle = foreground.copy()
pygame.draw.rect(foreground, game.color.dodgerblue * 0.75, rect, 7)
pygame.draw.rect(hover, game.color.dodgerblue, rect, 7)
pygame.draw.rect(toggle, game.color.dodgerblue * 0.5, rect, 7)
pygame.draw.rect(toggle, game.color.dodgerblue * 0.5,
rect.inflate(-20, -20))
b_rect = pygame.Rect(position, (30, 30))
button = game.DraftButton(b_rect, callback, text, True)
renderer = game.Renderer(button, foreground, hover, toggle,
self.group_buttons)
self.ui_events.add(button)
position = b_rect.x + 36, b_rect.centery
color = pygame.Color(text)
label = game.Label(text.capitalize(), self.font, color, position,
"midleft", self.group_labels)
return button
def on_draw(self, surface):
surface.fill(game.color.black)
surface.blit(self.toggle_surface, (200, 200))
self.label.draw(surface)
self.group_labels.draw(surface)
self.group_buttons.draw(surface)
def on_event(self, event):
self.ui_events.process_event(event)
def push_button(self, button):
self.label.set_text(button.user_data)
def toggle_color(self, button):
self.toggle.set_toggle(False)
self.toggle = button
self.toggle_surface.fill(pygame.Color(button.user_data))
class Scoreboards():
# 显示得分信息的类
def __init__(self, global_set, screen, stats):
# 初始化显示得分涉及的属性
self.screen = screen
self.screen_rect = screen.get_rect()
self.global_set = global_set
self.stats = stats
# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# 确定分数栏高度、宽度、背景色
self.score_bar_height = 50
self.score_bar_width = self.screen_rect.width
self.score_bar_bg_color = (180, 180, 255)
self.get_score_bar_height()
# 准备分数栏图片，仅初始化时生成一次
self.prep_score_bar()
# 准备包含最高得分、当前得分、等级和飞船数的图像
self.prep_images()
def get_score_bar_height(self):
self.high_test_image = self.font.render("Test_Height", True,
self.text_color,
self.global_set.bg_color)
self.high_test_rect = self.high_test_image.get_rect()
self.score_bar_height = self.high_test_rect.height * 1.5
def prep_images(self):
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score_bar(self):
# 准备分数栏图片
# 创建按钮的 rect 对象，并使其居中
self.score_bar_rect = pygame.Rect(0, 0, self.score_bar_width,
self.score_bar_height)
self.score_bar_rect.center = self.screen_rect.center
self.score_bar_rect.top = self.screen_rect.top
def prep_score(self):
# 将得分转换为一幅渲染的图像
# 取整
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.score_bar_bg_color)
# 将得分放在屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.centery = self.score_bar_rect.centery
self.score_rect.right = self.screen_rect.right - 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.ships.draw(self.screen)
def prep_high_score(self):
# 将最高得分转换为渲染的图像
high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(high_score)
high_score_str = 'Best:' + high_score_str
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.score_bar_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.centery = self.score_bar_rect.centery
def prep_level(self):
# 将等级转换为渲染的图像
alien_level_str = 'Level:' + str(self.stats.level)
self.level_image = self.font.render(alien_level_str, True,
self.text_color,
self.score_bar_bg_color)
# 将等级放在得分左方
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right - 260
self.level_rect.centery = self.score_bar_rect.centery
def prep_ships(self):
# 显示还余下多少艘飞船
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ships(self.global_set, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 0
self.ships.add(ship)
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)
self.prep_images()
def prep_images(self):
"""Prepare the initial score images."""
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
self.check_if_high_score()
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.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 show_score(self):
"""Draw scores, 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()
self.prep_level()
self.prep_ships()
self.write_high_score()
def check_if_high_score(self):
filename = 'high_score.json'
try:
with open(filename) as f:
self.stats.high_score = json.load(f)
self.prep_high_score()
except FileNotFoundError:
pass
else:
print("Brand new game - no new high_score")
def write_high_score(self):
filename = 'high_score.json'
with open(filename, 'w') as f:
json.dump(self.stats.score, f)
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)
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):
"""将得分转换为一幅渲染的图像"""
#round让小数精确到小数点后多少位，负数表示将数圆整到近10,100,1000等的整数倍
rounded_score=int(round(self.stats.score,-1))
#将数值转换为字符串时在其中插入逗号
score_str="{:,}".format(rounded_score)
#score_str=str(self.stats.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):
"""将最高分转换为一幅渲染的图像"""
#round让小数精确到小数点后多少位，负数表示将数圆整到近10,100,1000等的整数倍
rounded_score=int(round(self.stats.high_score,-1))
#将数值转换为字符串时在其中插入逗号
high_score_str="{:,}".format(rounded_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.right=self.score_rect.right
self.level_rect.top=self.score_rect.bottom + 10
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 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 run_game():
pg.init()
bullet_sound = pg.mixer.Sound("Bullet.wav")
pg.mixer.music.load("music.wav")
AI = Settings()
stats = Gamestats(AI)
# to store the bullets
alien_bullets_shoot = Group()
bullets = Group()
aliens = Group()
screen = pg.display.set_mode((AI.screen_width, AI.screen_height))
pg.display.set_caption("Space Wars")
print(str(AI.screen_width) + " " + str(AI.screen_height))
my_ship = ship(AI, screen, "my_ship.png", AI.screen_width / 2,
AI.screen_height - 30)
wallpaper = ship(AI, screen, "space.png", AI.screen_width / 2,
AI.screen_height)
# To make a play button
play_button = Button(AI, screen, "Play", AI.screen_width / 2 - 50,
AI.screen_height / 2 - 150, 42, (0, 0, 255),
(0, 255, 0), 0)
exit_button = Button(AI, screen, "Exit", AI.screen_width / 2 - 50,
AI.screen_height / 2 + 50, 42, (0, 0, 255),
(0, 255, 0), 0)
scoreboard = Button(AI, screen, "Leaderboard", AI.screen_width / 2 - 50,
AI.screen_height / 2 - 50, 40, (0, 0, 255),
(0, 255, 0), 50)
GameOver = Button(AI, screen, "Game over", AI.screen_width / 2 - 50,
AI.screen_height / 2, 50, (0, 0, 0), (0, 255, 0), 0)
bullet = Bullet(AI, screen, my_ship)
no_aliens = f.find_no_aliens(AI, screen, "alienship.png")
temp = 0
x = []
count = 0
tmp = random.randint(8, no_aliens)
for c in range(tmp):
x.append(c + 1)
random.shuffle(x)
pg.mixer.music.play(-1)
while True:
with open("file.txt") as score:
last_score = score.read()
if stats.ship_left > 0 and stats.game_active:
count = 1
if len(aliens) == 0:
bullets.empty()
if stats.game_active:
AI.increase_speed()
AI.score_increase += 2
AI.player_level += 1
temp = 0
x = []
tmp = random.randint(no_aliens - 4, no_aliens)
for c in range(tmp):
x.append(c + 1)
random.shuffle(x)
f.event_check(AI, screen, my_ship, bullets, stats, play_button,
aliens, bullets, bullet_sound, exit_button)
if stats.game_active:
if temp < tmp:
temp = f.create_fleet(AI, screen, aliens, "alienship.png",
no_aliens, temp, x)
my_ship.update()
f.bullets_collision_check(AI, aliens, bullets)
f.update_screen(AI, screen, my_ship, bullets, aliens, stats,
"my_ship.png", alien_bullets_shoot, last_score)
delete_bullets(bullet, bullets)
f.display_aliens(screen, AI, aliens, my_ship, stats, bullets)
if not stats.game_active:
wallpaper.blitme()
play_button.draw_button()
exit_button.draw_button()
scoreboard.draw_button()
pg.display.update()
else:
if count == 1:
c = 5
if int(last_score) < int(AI.player_score):
with open("file.txt", 'w') as file_object:
file_object.write(str(AI.player_score))
pg.mixer.music.pause()
while c > 0:
screen.fill((0, 0, 0))
msg = "Re-directing to main menu in....... " + str(c)
new_game = Button(AI, screen, msg,
AI.screen_width / 2 - 100, 30, 25,
(0, 0, 0), (255, 0, 0), 0)
new_game.draw_button()
GameOver.draw_button()
pg.display.update()
time.sleep(1)
c -= 1
count = 0
elif count == 0:
wallpaper.blitme()
play_button.draw_button()
exit_button.draw_button()
scoreboard.draw_button()
pg.display.update()
stats.game_active = False
f.event_check(AI, screen, my_ship, bullets, stats, play_button,
aliens, bullets, bullet_sound, exit_button)
pg.mixer.music.unpause()
pg.display.flip()
def process(q, cmd_thread):
# 初始化
pygame.init()
updated_frame = False # update a frame
settings = Settings("data\program_settings.json")
screen = pygame.display.set_mode(
(32 * settings.screen_scale + 2 * settings.screen_offset,
28 * settings.screen_scale + 2 * settings.screen_offset))
sbd = ScoreBoard("data\hiscore.csv")
passwd = Password(settings, screen)
tfunc.print_welcome()
team_flights = Group()
enemy_flights = Group()
team1 = TeamFlight([0.8, 0.8], [3.5, 0.5], [1.5, 1.5], [1.5, 26], settings,
screen)
team1.print_info()
team_flights.add(team1)
team2 = TeamFlight([0.8, 0.8], [5.5, 0.5], [5.5, 1.5], [5.5, 26], settings,
screen)
team2.print_info()
team_flights.add(team2)
team3 = TeamFlight([0.8, 0.8], [9.5, 0.5], [9.5, 1.5], [9.5, 26], settings,
screen)
team3.print_info()
team_flights.add(team3)
team4 = TeamFlight([0.8, 0.8], [11.5, 0.5], [13.5, 1.5], [13.5, 26],
settings, screen)
team4.print_info()
team_flights.add(team4)
enemy1 = EnemyFlight([0.8, 0.8], [2, 10],
settings,
screen,
rotate_angle=math.pi / 100)
enemy1.set_velocity([0, -0.11])
enemy1.print_info()
enemy_flights.add(enemy1)
enemy2 = EnemyFlight([0.8, 0.8], [13, 10],
settings,
screen,
rotate_angle=math.pi / 100)
enemy2.set_velocity([0, 0.11])
enemy2.print_info()
enemy_flights.add(enemy2)
enemy3 = EnemyFlight([0.8, 0.8], [2, 18],
settings,
screen,
rotate_angle=math.pi / 100)
enemy3.set_velocity([0, -0.11])
enemy3.print_info()
enemy_flights.add(enemy3)
enemy4 = EnemyFlight([0.8, 0.8], [13, 18],
settings,
screen,
rotate_angle=math.pi / 100)
enemy4.set_velocity([0, 0.11])
enemy4.print_info()
enemy_flights.add(enemy4)
person = Person([0.8, 0.8], [7.5, 0.9], settings, screen)
boxes = Boxes(settings, screen)
pygame.display.set_caption("Explore Reactor Room")
tfunc.update_screen(settings, screen, team_flights, enemy_flights, person,
boxes, passwd, sbd)
follow_status = False
while True:
start_time = time.time()
period_timeout = True
if settings.reset_request: # game reset
settings.reset_request = False
settings.paused = False
settings.init_game_args()
if settings.game_mode != 0: # set enemy mode according to game mode
settings.enemy_status = settings.game_mode + 3
person.reinit([0.8, 0.8], [7.5, 0.9])
boxes.reinit()
team1.reinit([0.8, 0.8], [3.5, 0.5], [1.5, 1.5], [1.5, 26])
team2.reinit([0.8, 0.8], [5.5, 0.5], [5.5, 1.5], [5.5, 26])
team3.reinit([0.8, 0.8], [9.5, 0.5], [9.5, 1.5], [9.5, 26])
team4.reinit([0.8, 0.8], [11.5, 0.5], [13.5, 1.5], [13.5, 26])
enemy1.reinit([0.8, 0.8], [2, 10], rotate_angle=math.pi / 100)
enemy1.set_velocity([0, -0.11])
enemy2.reinit([0.8, 0.8], [13, 10], rotate_angle=math.pi / 100)
enemy2.set_velocity([0, 0.11])
enemy3.reinit([0.8, 0.8], [2, 18], rotate_angle=math.pi / 100)
enemy3.set_velocity([0, -0.11])
enemy4.reinit([0.8, 0.8], [13, 18], rotate_angle=math.pi / 100)
enemy4.set_velocity([0, 0.11])
settings.enemy_status_changed = True
passwd.generate_passwd()
if settings.run_active and not settings.paused:
# 帧开始，执行每一帧的预处理
settings.timer = settings.timer + settings.time_period # 计算时间
if settings.clock_1 > 0: # 计算clock1时间
settings.clock_1 -= 1
else:
settings.clock_1 = 30
settings.change_font_color()
n_flights = len(team_flights.sprites()) + len(
enemy_flights.sprites()) #包含自己一共的飞机数
p_all = [[0, 0] for i in range(n_flights)]
p_all_direction = [0 for i in range(n_flights)]
index = 0
for team in team_flights.sprites():
p_all[index] = team.get_info()[0]
p_all_direction[index] = 0
index = index + 1
for enemy in enemy_flights.sprites():
p_all[index] = enemy.get_info()[0]
p_all_direction[index] = enemy.get_direction()
index = index + 1
# 更新其它状态
person.move()
boxes.update_info(settings, person)
settings.all_open = boxes.all_open()
if settings.all_open and person.get_info(
)[0][1] <= 0.5 and not settings.failed:
settings.complete = True
elif (settings.timer > 480 or person.get_hp_info()[0] <= 0
or settings.out_times * settings.time_period >= 10.0
) and not settings.complete:
settings.failed = True
if settings.complete and settings.game_mode != 0 and not settings.hiscore_recorded:
settings.hiscore_recorded = True
sbd.set_new_hiscore(settings.game_mode - 1,
settings.complete_time) # set hiscore
sbd.write_hiscore()
# 敌方无人机行动
if settings.enemy_status == 0: # 敌方无人机悬停
for enemy in enemy_flights.sprites():
enemy.set_velocity([0, 0])
enemy.move()
if settings.enemy_status_changed:
enemy.set_attack_args(2.4, 5.0)
enemy.attack(person, boxes)
elif settings.enemy_status == 1: # 敌方无人机直线运动
for enemy in enemy_flights.sprites():
enemy.move()
if settings.enemy_status_changed:
enemy.set_attack_args(2.4, 5.0)
enemy.attack(person, boxes)
elif settings.enemy_status == 2: # 敌方无人机圆周运动
for enemy in enemy_flights.sprites():
enemy.move_circle()
if settings.enemy_status_changed:
enemy.set_attack_args(2.4, 5.0)
enemy.attack(person, boxes)
elif settings.enemy_status == 3: # 敌方无人机逼近己方无人机
for enemy, team in zip(enemy_flights.sprites(),
team_flights.sprites()):
team_p_flight = team.get_info()[0]
enemy_p_flight = enemy.get_info()[0]
team_p_flight = [
team_p_flight[0] + random.random() * 4 - 2,
team_p_flight[1] + 1.5 + random.random() * 4 - 2
]
[vx, vy] = apf.compute_next_step(settings,
enemy_p_flight,
team_p_flight, [],
0, [],
is_team=False)
enemy.set_max_v(
settings.enemy_mission_args[1][3]) # medium velocity
enemy.set_velocity([vx / 1.5, vy / 1.5])
enemy.move()
if settings.enemy_status_changed:
enemy.set_attack_args(2.4, 5.0)
enemy.attack(person, boxes)
elif settings.enemy_status >= 4 and settings.enemy_status <= 6: # 执行任务状态
difficulty = settings.enemy_status - 4 # 0:简单 1:中等 2:困难
enemy_mission_args = settings.enemy_mission_args[difficulty]
is_first = True
flight_index = 0
p_offset = [[0, enemy_mission_args[6]],
[enemy_mission_args[6], 0],
[-enemy_mission_args[6], 0],
[0, -enemy_mission_args[6]]]
if boxes.is_in_protect_box(
person.get_info()[0]): # 在保护区域内，一架逼近人，三架逼近己方无人机
for enemy, team in zip(enemy_flights.sprites(),
team_flights.sprites()):
if is_first:
is_first = False
person_p_flight = person.get_info()[0]
enemy_p_flight = enemy.get_info()[0]
person_p_flight = [
person_p_flight[0] + random.random() * 4 - 2,
person_p_flight[1] + 2 +
random.random() * 2 * enemy_mission_args[1] -
enemy_mission_args[1]
]
[vx, vy] = apf.compute_next_step(settings,
enemy_p_flight,
person_p_flight,
[],
0, [],
is_team=False)
else:
team_p_flight = team.get_info()[0]
enemy_p_flight = enemy.get_info()[0]
team_p_flight = [
team_p_flight[0] + random.random() * 4 - 2,
team_p_flight[1] + 1.5 +
random.random() * 2 * enemy_mission_args[1] -
enemy_mission_args[1]
]
[vx, vy] = apf.compute_next_step(settings,
enemy_p_flight,
team_p_flight, [],
0, [],
is_team=False)
enemy.set_max_v(enemy_mission_args[3])
enemy.set_velocity([
vx * enemy_mission_args[0],
vy * enemy_mission_args[0]
])
enemy.move()
if settings.enemy_status_changed:
enemy.set_attack_args(enemy_mission_args[4],
enemy_mission_args[5])
enemy.attack(person, boxes)
else: # 在保护区域外，四架逼近人
for enemy, team in zip(enemy_flights.sprites(),
team_flights.sprites()):
person_p_flight = person.get_info()[0]
enemy_p_flight = enemy.get_info()[0]
person_p_flight = [
person_p_flight[0] + p_offset[flight_index][0] +
random.random() * 2 * enemy_mission_args[2] -
enemy_mission_args[2],
person_p_flight[1] + p_offset[flight_index][1] +
random.random() * 2 * enemy_mission_args[2] -
enemy_mission_args[2]
]
flight_index = flight_index + 1
[vx, vy] = apf.compute_next_step(settings,
enemy_p_flight,
person_p_flight, [],
0, [],
is_team=False)
enemy.set_max_v(enemy_mission_args[3])
enemy.set_velocity([
vx * enemy_mission_args[0],
vy * enemy_mission_args[0]
])
enemy.move()
if settings.enemy_status_changed:
enemy.set_attack_args(enemy_mission_args[4],
enemy_mission_args[5])
enemy.attack(person, boxes)
settings.enemy_status_changed = False
# 己方无人机行动
all_reach_final_goal = True # 假定都达到了密码箱位置(final pos)
if follow_status:
# 跟随主飞机模式
is_first = True
index = 0
for team in team_flights.sprites():
if not team.reach_final_goal():
all_reach_final_goal = False
if is_first:
is_first = False
p_flight = team.get_info()[0]
if p_flight[1] >= 26.1: #达成目标，恢复原队形
follow_status = False
p_goal = [1.5, 26]
team.set_goal(p_goal)
continue
p_leader = p_flight
p_goal = [tcmd_temp_line, 27.1]
team.set_goal(p_goal)
else:
if not follow_status: #恢复现场
p_goal[0] = p_goal[0] + 4
team.set_goal(p_goal)
continue
p_flight = team.get_info()[0]
team.set_goal([p_leader[0], p_leader[1] - index])
index = index + tcmd_follow_length
p_goal = team.get_goal()
[vx, vy] = apf.compute_next_step(settings,
p_flight,
p_goal,
p_all,
n_flights,
p_all_direction,
is_team=True)
[vx, vy] = [
vx + random.random() * 0.02 - 0.01,
vy + random.random() * 0.01 - 0.005
] # 速度扰动
team.set_velocity([vx, vy])
team.move()
team.heal(person, boxes)
else:
# 独立模式
for team in team_flights.sprites():
if not team.reach_final_goal():
all_reach_final_goal = False
p_flight = team.get_info()[0]
p_goal = team.get_goal()
[vx, vy] = apf.compute_next_step(settings,
p_flight,
p_goal,
p_all,
n_flights,
p_all_direction,
is_team=True)
[vx, vy] = [
vx + random.random() * 0.02 - 0.01,
vy + random.random() * 0.01 - 0.005
] # 速度扰动
team.set_velocity([vx, vy])
team.move()
team.heal(person, boxes)
if not settings.crack_qrcode:
boxes.crack(all_reach_final_goal) # 全部到达目的地，破译密码
# 获取终端指令
if not q.empty():
try:
[cmd_content, cmd_args] = q.get().split(' ', 1)
if cmd_content == "thenextcontentisthepassword":
# 玩家输入密码
try:
tcmd_passwd = cmd_args
if passwd.check_passwd(tcmd_passwd):
print("[Boxes] Password correct.")
settings.get_key = True
else:
print("[Boxes] Password error, try again.")
except:
print("[Boxes] Password input error.")
elif cmd_content == "y":
# 更改己方飞机目标点（Y轴平齐）策略
try:
[cmd_arg_1, cmd_arg_2] = cmd_args.split(' ')
new_goal = float(cmd_arg_1)
interval = float(cmd_arg_2)
except:
new_goal = float(cmd_args)
interval = 4.0
x_offset = 7.5 - interval * 1.5
print(
"[Team] Move team flights to Y-line %.3f m with interval %.3f m ."
% (new_goal, interval))
for team in team_flights.sprites():
team.set_goal([x_offset, new_goal])
x_offset += interval
elif cmd_content == "f":
# 跟随主飞机运动策略
[cmd_arg_1, cmd_arg_2] = cmd_args.split(' ')
tcmd_temp_line = float(cmd_arg_1)
tcmd_follow_length = float(cmd_arg_2)
print(
"[Team] Follow the leader team flight with X-line %.3f m and interval %.3f m ."
% (tcmd_temp_line, tcmd_follow_length))
follow_status = True
elif cmd_content == "s":
# 即刻在前方悬停策略
follow_status = False
ahead_length = float(cmd_args)
print("[Team] Hover at %.3f m ahead ." %
(ahead_length))
for team in team_flights.sprites():
temp_goal = team.get_info()[0]
team.set_goal(
[temp_goal[0], temp_goal[1] + ahead_length])
else:
print("[Team] Unknown command.")
except:
print("[Team] Command error.")
if settings.crack_qrcode and not settings.get_key:
cmd_thread.input_passwd_request() # input the password in tcmd
tfunc.update_screen(settings, screen, team_flights, enemy_flights,
person, boxes, passwd, sbd)
# Watch update frame time (for test)
#if updated_frame:
# updated_frame = False
# print("Update time: %.3fs" % (time.time() - start_time))
# 等待更新时间
while period_timeout:
tfunc.check_events(settings, screen, cmd_thread, team_flights,
enemy_flights, person, sbd)
if time.time() - start_time >= 0.04:
period_timeout = False
updated_frame = True
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.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.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)
def run_game():
# 初始化游戏并创建一个屏幕对象 初始化pygame、设置和屏幕对象
pygame.init()
# 设置窗口出现的位置
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (40, 55)
# 初始化一个设置实例
ai_settings = Settings()
# 设置屏幕大小
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
# # 设置屏幕大小(全屏)
# screen = pygame.display.set_mode(
# (ai_settings.screen_width, ai_settings.screen_height), pygame.FULLSCREEN)
# 设置标题
pygame.display.set_caption("Thunder Fighters Vs Digital Monsters")
#加载背景音乐
my_music = Music(ai_settings)
my_music.menu_music()
# 创建Play按钮
play_button = Button(ai_settings, screen)
# 创建一个用于存储游戏统计信息的实例
stats = GameStats(ai_settings)
# 创建一艘飞船
ship = Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = Group()
# 创建一个外星人编组
aliens = Group()
# # 创建一个外星人
# gf.create_alien(ai_settings, screen, aliens, stats)
# 创建存储游戏统计信息的实例，并创建记分牌
sb = Scoreboard(ai_settings, screen, stats)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, my_music)
if stats.game_active:
# 在更新屏幕之前调用飞船的方法
ship.update()
# 更新子弹状态
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, my_music)
# 更新外星人
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets, my_music)
# 更新屏幕
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
class FireBallController:
# controls fireballs
def __init__(self, screen, map_group, obstacles, floor, origin, goomba,
koopa):
self.screen = screen
self.origin = origin
self.map_group = map_group
self.obstacles = obstacles
self.floor = floor
self.goomba, self.koopa = goomba, koopa
self.fireballs = Group()
self.fb_images = [
pygimg.load('images/super_mario_fireball_1.png'),
pygimg.load('images/super_mario_fireball_2.png'),
pygimg.load('images/super_mario_fireball_3.png'),
pygimg.load('images/super_mario_fireball_4.png')
]
self.exp_images = [
pygimg.load('images/super_mario_fireball_explode_1.png'),
pygimg.load('images/super_mario_fireball_explode_2.png'),
pygimg.load('images/super_mario_fireball_explode_3.png')
]
self.fb_images = [
transform.scale(img, (16, 16)) for img in self.fb_images
]
self.exp_images = [
transform.scale(img, (16, 16)) for img in self.exp_images
]
def throw_fireball(self):
# throws fireball if there are less than 2
if len(self.fireballs) < 2:
if self.origin.state_info['facing_right']:
n_fireball = FireBall(self.origin.rect.topright[0],
self.origin.rect.topright[1],
self.fb_images, self.exp_images,
self.obstacles, self.floor, self.goomba,
self.koopa)
else:
n_fireball = FireBall(self.origin.rect.topleft[0],
self.origin.rect.topleft[1],
self.fb_images,
self.exp_images,
self.obstacles,
self.floor,
self.goomba,
self.koopa,
speed=-5)
self.fireballs.add(n_fireball)
self.map_group.add(n_fireball)
return True
return False
def update_fireballs(self):
# updates all fireballs
self.fireballs.update()
for fb in self.fireballs:
if fb.rect.x < (self.origin.rect.x - self.screen.get_width()) or \
fb.rect.x > (self.origin.rect.x + self.screen.get_width()) or \
(fb.rect.y < (self.origin.rect.y - self.screen.get_height()) or
fb.rect.y > (self.origin.rect.y + self.screen.get_height())):
fb.kill()
def _draw_cloud(tag_list,
layout=LAYOUT_MIX,
size=(500, 500),
fontname=DEFAULT_FONT,
rectangular=False):
# sort the tags by size and word length
tag_list.sort(key=lambda tag: len(tag['tag']))
tag_list.sort(key=lambda tag: tag['size'])
tag_list.reverse()
# create the tag space
tag_sprites = []
area = 0
for tag in tag_list:
# print tag, fontname
tag_sprite = Tag(tag, (0, 0), fontname=fontname)
area += tag_sprite.mask.count()
tag_sprites.append(tag_sprite)
canvas = Rect(0, 0, 0, 0)
ratio = float(size[1]) / size[0]
if rectangular:
spiral = _rectangular_spiral
else:
spiral = _archimedean_spiral
aligned_tags = Group()
for tag_sprite in tag_sprites:
angle = 0
if layout == LAYOUT_MIX and randint(0, 2) == 0:
angle = 90
elif layout == LAYOUT_VERTICAL:
angle = 90
tag_sprite.rotate(angle)
xpos = canvas.width - tag_sprite.rect.width
if xpos < 0: xpos = 0
xpos = randint(int(xpos * LOWER_START), int(xpos * UPPER_START))
tag_sprite.rect.x = xpos
ypos = canvas.height - tag_sprite.rect.height
if ypos < 0: ypos = 0
ypos = randint(int(ypos * LOWER_START), int(ypos * UPPER_START))
tag_sprite.rect.y = ypos
_search_place(tag_sprite, aligned_tags, canvas, spiral, ratio)
canvas = _get_tags_bounding(aligned_tags)
# resize cloud
zoom = min(float(size[0]) / canvas.w, float(size[1]) / canvas.h)
for tag in aligned_tags:
tag.rect.x *= zoom
tag.rect.y *= zoom
tag.rect.width *= zoom
tag.rect.height *= zoom
tag.tag['size'] = int(tag.tag['size'] * zoom)
tag.update_fontsize()
canvas = _get_tags_bounding(aligned_tags)
return canvas, aligned_tags
class Ship(Sprite):
images = [pg.image.load('images/ship.bmp')]
images_for_boom = [
pg.image.load('images/ship_boom' + str(i) + '.png') for i in range(7)
]
timer = Timer(frames=images, wait=1000)
timer_boom = Timer(frames=images_for_boom, wait=100, looponce=True)
def __init__(self, sound, game, barriers=None, aliens=None):
"""Initialize the ship and set its starting position."""
super().__init__()
self.settings = game.settings
self.screen = game.screen
self.sound = sound
self.game = game
self.barriers = barriers
self.aliens = aliens
self.image = pg.image.load('images/ship.bmp')
self.rect = self.image.get_rect()
self.screen_rect = game.screen.get_rect()
self.center = 0
self.center_ship()
self.moving_right = False
self.moving_left = False
self.shooting_bullets = False
self.bullets_attempted = 0
self.dead, self.reallydead, self.timer_switched = False, False, False
self.ship_group = Group()
self.ship_group.add(
self
) # only one Ship (myself) in the Ship group to simplify collision tracking
self.bullet_group_that_kill_aliens = Group()
self.timer = Ship.timer
# self.bullets = Bullets(settings=game.settings, is_alien_bullet=False)
def add_bullet(self, game, x, y):
self.bullet_group_that_kill_aliens.add(
BulletFromShip(game=self.game,
x=self.rect.centerx,
y=self.rect.top))
def bullet_group(self):
return self.bullet_group_that_kill_aliens
def group(self):
return self.ship_group
def killed(self):
if not self.dead and not self.reallydead: self.dead = True
if self.dead and not self.timer_switched:
self.timer = Ship.timer_boom
self.timer_switched = True
def center_ship(self):
self.rect.centerx = self.screen_rect.centerx
self.rect.bottom = self.screen_rect.bottom
self.center = float(self.rect.centerx)
def update(self):
self.bullet_group_that_kill_aliens.update()
if self.dead and self.timer_switched:
if self.timer.finished:
self.dead = False
self.timer_switched = False
self.reallydead = True
self.timer.reset()
self.game.reset()
for bullet in self.bullet_group_that_kill_aliens.copy():
if bullet.rect.bottom < 0:
self.bullet_group_that_kill_aliens.remove(bullet)
bullet_alien_collisions = pg.sprite.groupcollide(
self.aliens.group(), self.bullet_group_that_kill_aliens, False,
True)
if bullet_alien_collisions:
for alien in bullet_alien_collisions:
alien.killed()
bullet_barrier_collisions = pg.sprite.groupcollide(
self.barriers.group(), self.bullet_group_that_kill_aliens, False,
True)
# TODO: you MUST change True, True to False, True on the previous line if you only damage the barrier block
if bullet_barrier_collisions:
for barrier_block in bullet_barrier_collisions:
barrier_block.damaged()
if len(self.aliens.group()) == 0:
self.bullet_group_that_kill_aliens.empty()
self.settings.increase_speed()
self.aliens.create_fleet()
self.game.stats.level += 1
self.game.sb.prep_level()
delta = self.settings.ship_speed_factor
if self.moving_right and self.rect.right < self.screen_rect.right:
self.center += delta
if self.moving_left and self.rect.left > 0: self.center -= delta
if self.shooting_bullets and not self.dead:
self.sound.shoot_bullet()
self.add_bullet(game=self.game, x=self.rect.x, y=self.rect.y)
self.shooting_bullets = False
self.rect.centerx = self.center
def draw(self):
for bullet in self.bullet_group_that_kill_aliens:
bullet.draw()
image = self.timer.imagerect()
rect = image.get_rect()
rect.x, rect.y = self.rect.centerx, self.rect.top
self.screen.blit(image, rect)
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 = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score image.
# To turn the text to be displayed into an 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) # stats.score to string convert
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)
# 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 = 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)
# 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 from the value stored in stats.level
self.level_image = self.font.render(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.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()
# loop runs once for every ship the player has left
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 at the location specified
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)
def run_game_2():
global ch, dobollet, t, bulets, t2
forrand = 1000
pygame.init()
pygame.joystick.init()
joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
for joystick in joysticks:
joystick.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)
ship2 = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
ships = Group()
ships.add(ship)
ships2 = Group()
ships2.add(ship2)
blocks = Group()
cu = 1
cd = 1
cr = 1
moneys = 0
cl = 1
cu2 = 1
cd2 = 1
cr2 = 1
ship.y -= 47
ship.rect.y = ship.y
moneys = 0
cl2 = 1
tank = 0
fuster = 1
poweraps = Group()
updatenow = 0
bezero = 0
die_blocks = Group()
tr = '[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,0,0,1,4,0,3,3,3,0,7,0,1,1,1,1,2,1,0,0,0,0,0,0,1,4,7,6,3,0,0,1,0,0,0,0,0,1,2,1,0,0,1,0,0,0,1,4,4,3,3,0,1,0,0,1,0,0,1,2,1,0,0,1,1,1,0,1,1,1,1,1,1,0,0,0,7,7,6,0,1,2,1,0,0,1,0,0,4,1,0,0,0,1,0,0,0,0,1,0,0,1,2,1,0,0,0,0,0,4,1,0,7,6,6,0,1,0,3,0,4,3,0,0,1,2,1,0,4,0,7,7,4,0,0,0,3,1,0,3,0,0,0,0,0,1,2,1,0,4,1,7,7,4,1,4,4,0,1,1,1,1,1,1,0,4,1,2,1,3,4,3,1,7,7,1,1,7,7,7,7,7,7,7,0,0,0,1,2,1,3,4,3,1,7,7,7,7,6,7,7,7,6,7,7,7,7,0,0,0,1,2,1,3,4,3,1,1,7,7,1,1,1,1,1,7,7,7,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1'
filename = 'liberint_boss.txt'
# t = []
alienbullets = Group()
nothing = Group()
score = 0
ch = 50
jkd = Group()
t2 = 1
do_liberint(pygame, Block, blocks, ai_settings, screen, filename,
warrior, aliens, poweraps)
for power in poweraps.sprites():
power.image = pygame.image.load('bomb.gif')
joycon.set_player_lamp_flashing(1)
joycon2.set_player_lamp_flashing(2)
bg_color = (20, 260, 200)
invis = 0
ships.add(ship)
i1 = 0
i2 = 0
innothing = Group()
ships2.add(ship2)
shoot = pygame.mixer.Sound('07 - Metal Man.mp3')
shoot.play(-1)
collision = pygame.sprite.groupcollide(ships, blocks, false, True)
collision = pygame.sprite.groupcollide(ships2, blocks, False, True)
collision = pygame.sprite.groupcollide(ships, aliens, false, True)
collision = pygame.sprite.groupcollide(ships2, aliens, False, True)
collision = pygame.sprite.groupcollide(aliens, blocks, false, True)
# shoot = mixer.Sound("C:\windows\media\Ring02.wav")
# #C:\windows\downloads\
ch = 10
timer = 5
while True:
pygame.time.wait(timer)
screen.fill(ai_settings.bg_color)
isstickbut = joycon.stick_r_btn
isstickmove = joycon.stick_r
if isstickmove[1] > 2000:
ship.rect.x += 3
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.x -= 3
t = 2
#('up')
elif isstickmove[1] < 1000:
#ship.y += 3
#('down')
ship.rect.x -= 3
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.x += 3
t = 3
elif isstickmove[0] > 3000:
#ship.x += 3
#('r')
ship.rect.y += 3
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.y -= 3
t = 1
elif isstickmove[0] < 1000:
#ship.x -= 3
#('l')
t = 0
ship.rect.y -= 3
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.y += 3
isstickbut = joycon2.stick_l_btn
isstickmove = joycon2.stick_l
if isstickmove[1] > 3000:
ship2.rect.x -= 3
t2 = 3
if pygame.sprite.spritecollideany(ship2, blocks):
ship2.rect.x += 3
#('up')
elif isstickmove[1] < 2000:
#ship.y += 3
#('down')
t2 = 2
ship2.rect.x += 3
if pygame.sprite.spritecollideany(ship2, blocks):
ship2.rect.x -= 3
elif isstickmove[0] > 3000:
#ship.x += 3
#('r')
ship2.rect.y -= 3
t2 = 0
if pygame.sprite.spritecollideany(ship2, blocks):
ship2.rect.y += 3
elif isstickmove[0] < 1600:
#ship.x -= 3
#('l')
t2 = 1
ship2.rect.y += 3
if pygame.sprite.spritecollideany(ship2, blocks):
ship2.rect.y -= 3
# isstickmove=joycon2.stick_l
# if isstickmove[1] > 3000:
# ship2.rect.x += 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.x -= 1
# elif isstickmove[1] < 1000:
# #ship.y += 3
# #('down')
# ship.rect.x -= 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.x += 1
# elif isstickmove[0] > 3000:
# #ship.x += 3
# #('r')
# ship2.rect.y += 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.y -= 1
# elif isstickmove[0] < 1000:
# #ship.x -= 3
# #('l')
# ship2.rect.y -= 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.y += 1
for event_type, status in joycon.events():
if status == 1:
if event_type == 'b':
bul = Bullet(ai_settings, screen, ship, 1, 1, 1, t)
bullets.add(bul)
if event_type == 'y':
nothingi = Block(ai_settings, screen, 'fire.gif')
nothingi.rect.x, nothingi.rect.y = ship.rect.x, ship.rect.y
if t == 0:
nothingi.rect.y -= 60
if t == 1:
nothingi.rect.y += 60
if t == 2:
nothingi.rect.x += 60
if t == 3:
nothingi.rect.x -= 60
blocks.add(nothingi)
innothing.add(nothingi)
if event_type == 'a':
nothingi = Block(ai_settings, screen, 'fire.gif')
nothingi.rect.x, nothingi.rect.y = ship.rect.x, ship.rect.y
blocks.add(nothingi)
innothing.add(nothingi)
if event_type == 'right_sr':
if timer == 5:
timer = 50
else:
timer = 5
for event_type, status in joycon2.events():
if status == 1:
if event_type == 'up':
bul = Bullet(ai_settings, screen, ship2, 1, 1, 1, t2)
bullets.add(bul)
if event_type == 'left_sr':
if timer == 5:
timer = 50
else:
timer = 5
if event_type == 'right':
nothingi = Block(ai_settings, screen, 'fire.gif')
nothingi.rect.x, nothingi.rect.y = ship2.rect.x, ship2.rect.y
if t2 == 0:
nothingi.rect.y -= 60
if t2 == 1:
nothingi.rect.y += 60
if t2 == 2:
nothingi.rect.x += 60
if t2 == 3:
nothingi.rect.x -= 60
blocks.add(nothingi)
innothing.add(nothingi)
if event_type == 'left':
nothingi = Block(ai_settings, screen, 'fire.gif')
nothingi.rect.x, nothingi.rect.y = ship2.rect.x, ship2.rect.y
blocks.add(nothingi)
innothing.add(nothingi)
#(event_type, status)
# for event_type, status in joycon3.events():
# #("ButtonEventJoyCon:")
# #(event_type, status)
# for event_type, status in joycon4.events():
# #("ButtonEventJoyCon:")
# #(event_type, status)
screen.fill(ai_settings.bg_color)
jkd.draw(screen)
for bul in bullets.sprites():
bul.draw_bullet()
alienbullets.draw(screen)
blocks.draw(screen)
die_blocks.draw(screen)
ships.draw(screen)
ships2.draw(screen)
bullets.update(1, 1)
collision = pygame.sprite.groupcollide(bullets, innothing, True,
True)
collision = pygame.sprite.groupcollide(alienbullets, innothing,
True, True)
collision = pygame.sprite.groupcollide(bullets, blocks, True,
false)
collision = pygame.sprite.groupcollide(bullets, blocks, True,
false)
collision = pygame.sprite.groupcollide(bullets, blocks, True,
false)
collision = pygame.sprite.groupcollide(alienbullets, blocks, True,
false)
collision = pygame.sprite.groupcollide(alienbullets, bullets, True,
True)
collision2 = pygame.sprite.groupcollide(bullets, aliens, True,
False)
if collision2:
bullets.empty()
print(len(bullets))
ch -= 1
for x in range(10):
bullet = Bullet(ai_settings, screen, alien, aliens,
alienbullets, ship, 0)
alienbullets.add(bullet)
bullet = Bullet(ai_settings, screen, alien, aliens,
alienbullets, ship, 1)
alienbullets.add(bullet)
bullet = Bullet(ai_settings, screen, alien, aliens,
alienbullets, ship, 2)
alienbullets.add(bullet)
bullet = Bullet(ai_settings, screen, alien, aliens,
alienbullets, ship, 3)
alienbullets.add(bullet)
print(ch)
if ch == 0:
collision2 = pygame.sprite.groupcollide(
bullets, aliens, False, False)
shoot.stop()
break
collision = pygame.sprite.groupcollide(bullets, alienbullets, True,
True)
aliens.draw(screen)
alienbullets.update()
bullets.update(9, 9)
alienbullets.update()
blocks.draw(screen)
for alien in aliens.sprites():
if randint(0, 0) == 0 and len(alienbullets) <= 8:
bullet = Alien(ai_settings, screen, alien, aliens,
alienbullets)
alienbullets.add(bullet)
bullet = Alien(ai_settings, screen, alien, aliens,
alienbullets)
alienbullets.add(bullet)
bullet = Alien(ai_settings, screen, alien, aliens,
alienbullets)
alienbullets.add(bullet)
bullet = Alien(ai_settings, screen, alien, aliens,
alienbullets)
alienbullets.add(bullet)
tre = randint(0, 150)
if tre == 45:
alien.t = randint(0, 3)
if pygame.sprite.spritecollideany(alien, blocks):
if alien.t == 0:
alien.y += 3
alien.rect.y += 3
if alien.t == 1:
alien.y -= 3
alien.rect.y -= 3
if alien.t == 2:
alien.x -= 3
alien.rect.x -= 3
if alien.t == 3:
alien.x += 3
alien.rect.x += 3
alien.t = randint(0, 3)
if pygame.sprite.spritecollideany(ship, aliens):
shoot.stop()
shoot = pygame.mixer.Sound('27 - Game Over.mp3')
shoot.play(-1)
aliens.clear()
alienbullets.clear()
pygame.quit()
run_game()
sys.exit()
if pygame.sprite.spritecollideany(ship2, aliens):
shoot.stop()
shoot = pygame.mixer.Sound('27 - Game Over.mp3')
shoot.play(0)
sys.exit()
pygame.quit()
run_game()
if pygame.sprite.spritecollideany(ship, alienbullets):
shoot.stop()
shoot = pygame.mixer.Sound('27 - Game Over.mp3')
shoot.play(-1)
shoot.stop()
pygame.quit()
sys.exit()
run_game()
if pygame.sprite.spritecollideany(ship2, alienbullets):
shoot.stop()
shoot = pygame.mixer.Sound('27 - Game Over.mp3')
shoot.play(0)
shoot.stop()
pygame.quit()
run_game()
print(len(aliens), len(alienbullets))
pygame.display.flip()
def run_game():
global ch, dobollet, t, bulets, t2
forrand = 1000
pygame.init()
pygame.joystick.init()
joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
for joystick in joysticks:
joystick.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)
ship2 = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
ships = Group()
ships.add(ship)
ships2 = Group()
ships2.add(ship2)
blocks = Group()
cu = 1
cd = 1
cr = 1
moneys = 0
cl = 1
cu2 = 1
cd2 = 1
cr2 = 1
ship.y -= 47
ship.rect.y = ship.y
moneys = 0
cl2 = 1
tank = 0
fuster = 1
poweraps = Group()
updatenow = 0
bezero = 0
die_blocks = Group()
tr = '[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,0,0,0,0,0,0,1,4,0,3,3,3,0,7,0,1,1,1,1,2,1,0,0,0,0,0,0,1,4,7,6,3,0,0,1,0,0,0,0,0,1,2,1,0,0,1,0,0,0,1,4,4,3,3,0,1,0,0,1,0,0,1,2,1,0,0,1,1,1,0,1,1,1,1,1,1,0,0,0,7,7,6,0,1,2,1,0,0,1,0,0,4,1,0,0,0,1,0,0,0,0,1,0,0,1,2,1,0,0,0,0,0,4,1,0,7,6,6,0,1,0,3,0,4,3,0,0,1,2,1,0,4,0,7,7,4,0,0,0,3,1,0,3,0,0,0,0,0,1,2,1,0,4,1,7,7,4,1,4,4,0,1,1,1,1,1,1,0,4,1,2,1,3,4,3,1,7,7,1,1,7,7,7,7,7,7,7,0,0,0,1,2,1,3,4,3,1,7,7,7,7,6,7,7,7,6,7,7,7,7,0,0,0,1,2,1,3,4,3,1,1,7,7,1,1,1,1,1,7,7,7,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1'
filename = 'liberint.txt'
# t = []
alienbullets = Group()
score = 0
do_liberint(pygame, Block, blocks, ai_settings, screen, poweraps,
filename, Alien_what_go_up_and_down,
Alien_what_go_left_and_right, aliens, aliens)
for power in poweraps.sprites():
power.image = pygame.image.load('bomb.gif')
bg_color = (20, 250, 200)
invis = 0
ships.add(ship)
for block in blocks.sprites():
if pygame.sprite.spritecollideany(block, ships):
blocks.remove(block)
#shoot = mixer.Sound('Contra.mp3')
#shoot.play(-1)
# shoot = mixer.Sound("C:\windows\media\Ring02.wav")C:\windows\downloads\
while True:
for block in aliens.sprites():
if pygame.sprite.spritecollideany(block, blocks):
block.direction += 1
if block.direction == 4:
block.direction = 0
if random.randint(0, 1000) == 23:
alien = Alien(ai_settings, screen, 0, 0, ship)
aliens.add(alien)
while pygame.sprite.spritecollideany(alien, blocks):
alien.x = randint(0, ai_settings.screen_width)
alien.y = randint(0, ai_settings.screen_height)
alien.rect.x = alien.x
alien.rect.y = alien.y
# for event_type, status in joycon1.events():
# if status == 1:
# if
isstickmove = joycon.stick_r
if isstickmove[1] > 3000:
ship.rect.x += 1
t = 2
ship.image = pygame.image.load('tank_left.gif')
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.x -= 1
elif isstickmove[1] < 1000:
#ship.y += 3
print('down')
ship.rect.x -= 1
t = 3
ship.image = pygame.image.load('tank_right.gif')
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.x += 1
elif isstickmove[0] > 3000:
#ship.x += 3
print('r')
ship.rect.y += 1
t = 1
ship.image = pygame.image.load('tank_down.gif')
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.y -= 1
elif isstickmove[0] < 1000:
#ship.x -= 3
print('l')
ship.rect.y -= 1
ship.image = pygame.image.load('tank_up.gif')
t = 0
if pygame.sprite.spritecollideany(ship, blocks):
ship.rect.y += 1
# isstickmove=joycon2.stick_l
# if isstickmove[1] > 3000:
# ship2.rect.x += 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.x -= 1
# elif isstickmove[1] < 1000:
# #ship.y += 3
# print('down')
# ship.rect.x -= 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.x += 1
# elif isstickmove[0] > 3000:
# #ship.x += 3
# print('r')
# ship2.rect.y += 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.y -= 1
# elif isstickmove[0] < 1000:
# #ship.x -= 3
# print('l')
# ship2.rect.y -= 1
# if pygame.sprite.spritecollideany(ship2,blocks):
# ship2.rect.y += 1
for event_type, status in joycon.events():
if status == 1:
if event_type == 'x':
bul = Bullet(ai_settings, screen, ship, 1, 1, 1, t)
bullets.add(bul)
print(event_type, status)
# for event_type, status in joycon3.events():
# print("ButtonEventJoyCon:")
# print(event_type, status)
# for event_type, status in joycon4.events():
# print("ButtonEventJoyCon:")
# print(event_type, status)
if len(alienbullets) <= 0:
for alien in aliens.sprites():
if randint(0, 500) == 34:
bul = Bullet(ai_settings, screen, alien, 2, 1, alien,
0)
alienbullets.add(bul)
screen.fill(ai_settings.bg_color)
for bul in bullets.sprites():
bul.draw_bullet()
for bul in alienbullets.sprites():
bul.draw_bullet()
blocks.draw(screen)
die_blocks.draw(screen)
ships.draw(screen)
ships2.draw(screen)
bullets.update(1, 1)
collision = pygame.sprite.groupcollide(bullets, blocks, True,
false)
collision = pygame.sprite.groupcollide(alienbullets, blocks, True,
false)
collision = pygame.sprite.groupcollide(bullets, aliens, True, True)
collision = pygame.sprite.groupcollide(bullets, alienbullets, True,
True)
collision = pygame.sprite.groupcollide(ships, alienbullets, True,
True)
aliens.draw(screen)
aliens.update()
alienbullets.update(2, 1)
pygame.display.flip()
class Scoreboard:
def __init__(self, ai_settings, screen, maze, pacman):
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.pacman = pacman
self.maze = maze
# self.stats = stats
self.text_color = (255, 255, 255)
self.font = pygame.font.SysFont(None, 48)
self.score_image = None
self.score_rect = None
self.high_score_image = None
self.high_score_rect = None
self.level_image = None
self.level_rect = None
self.ships = None
self.pacmans = Group()
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_pacmans()
def prep_score(self):
rounded_score = int(round(self.ai_settings.score, -1))
score_str = "{:,}".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.right = self.screen_rect.right - 20
self.score_rect.top = 20
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.pacmans.draw(self.screen)
def prep_high_score(self):
"""Turn the high score into a rendered image."""
high_score = int(round(self.ai_settings.hs, -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)
# Cetner 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."""
self.level_image = self.font.render(str(self.ai_settings.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.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10
def prep_pacmans(self):
"""SHow how many ships are left."""
self.pacmans = Group()
for pacman_number in range(self.ai_settings.lives_left):
pacman = Pacman(self.ai_settings, self.screen, self.maze)
pacman.rect.x = 10 + pacman_number * pacman.rect.width
pacman.rect.y = 10
self.pacmans.add(pacman)
from view import draw
if __name__ == "__main__":
pygame.init()
pygame.font.init()
screen = pygame.display.set_mode(size=(WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption('Danmaku')
clock = pygame.time.Clock()
game_state = GameState()
play_button = Button()
bg = Background()
scoreboard = Scoreboard(game_state)
player_bullets = Group()
player = Player(player_bullets)
enemy_group = Group()
enemy_bullets = Group()
enemy_group.add(Enemy(enemy_bullets, player))
screenRect = pygame.Rect(0, 0, WIDTH, HEIGHT)
while 1:
handle_input(player, enemy_group, game_state, play_button)
if game_state.state == RUNNING:
player.update()
player_bullets.update()
enemy_group.update()
def run_game():
due = time.time()
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 创建play按钮
play_button = Button(ai_settings=ai_settings, screen=screen, msg="Play")
# 创建一个用于存储游戏统计信息的实例，并创建记分牌
stats = GameStats(ai_settings=ai_settings)
sb = Scoreboard(ai_settings=ai_settings, screen=screen, stats=stats)
# 创建一艘飞船
ship = Ship(ai_settings=ai_settings, screen=screen)
# 创建一个用于存储子弹的编组
bullets = Group()
bullet_type = 0
# 创建外星人群
aliens = Group()
gf.create_fleet(ai_settings=ai_settings,
screen=screen,
ship=ship,
aliens=aliens)
while True:
gf.update_screen(ai_settings=ai_settings,
screen=screen,
stats=stats,
scoreboard=sb,
ship=ship,
aliens=aliens,
bullets=bullets,
play_button=play_button)
gf.check_events(ai_settings=ai_settings,
screen=screen,
stats=stats,
play_button=play_button,
scoreboard=sb,
ship=ship,
aliens=aliens,
bullets=bullets)
if stats.game_active:
ship.update()
due = gf.fire_bullet(ai_settings=ai_settings,
screen=screen,
ship=ship,
bullets=bullets,
due=due,
bullet_type=bullet_type)
gf.update_bullets(ai_settings=ai_settings,
screen=screen,
stats=stats,
scoreboard=sb,
ship=ship,
aliens=aliens,
bullets=bullets)
gf.update_aliens(ai_settings=ai_settings,
stats=stats,
screen=screen,
scoreboard=sb,
ship=ship,
aliens=aliens,
bullets=bullets)
def __init__(self,
screen_width=1500,
screen_height=700,
fps=60,
background_image=None):
'''Initializes the game object and also the game'''
# initialize pygame (handles pretty much eveything)
pg.init()
# create clock
self.clock = pg.time.Clock()
self.background_image = pg.image.load(
'./graphics/misc/star_wars_background_24bit.bmp')
self.fps = fps
# initialize main screen
size = screen_width, screen_height # set screen size
self.screen = pg.display.set_mode(size)
# load meta data
with open('./meta/sprite_skins_meta_data.yaml',
'r') as skins_meta_file:
skins_meta_data = yaml.load(skins_meta_file)
with open('./meta/animations_meta_data.yaml',
'r') as animations_meta_file:
animations_meta_data = yaml.load(animations_meta_file)
# set player and enemy ship and laser types
allied_ship, allied_laser = 'tieinterceptor', 'green'
hostile_ship, hostile_laser = 'xwing', 'red'
# set game attributes from meta data for player
# skin specific
self.allied_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[allied_ship]['image_paths']
]
self.allied_gun_offsets = np.array(
skins_meta_data[allied_ship]['gun_offsets']).astype('float')
self.allied_engine_offsets = np.array(
skins_meta_data[allied_ship]['engine_offsets']).astype('float')
self.allied_fire_modes = skins_meta_data[allied_ship]['fire_modes']
# laser specific
self.allied_laser_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[allied_laser]['image_paths']
]
self.allied_laser_sound = pg.mixer.Sound(
animations_meta_data[allied_laser]['sound'])
self.allied_muzzle_images = [
pg.image.load(image_path)
for image_path in animations_meta_data[allied_laser]['image_paths']
]
self.allied_muzzle_spi = animations_meta_data[allied_laser]['spi']
# set game attributes from meta data for enemies
# behavioural
self.piloting_cone_sine = 0.1
self.gunning_cone_sine = 0.1
# skin specific
self.hostile_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[hostile_ship]['image_paths']
]
self.hostile_gun_offsets = np.array(
skins_meta_data[hostile_ship]['gun_offsets']).astype('float')
self.hostile_engine_offsets = np.array(
skins_meta_data[hostile_ship]['engine_offsets']).astype('float')
self.hostile_fire_modes = skins_meta_data[hostile_ship]['fire_modes']
# laser specific
self.hostile_laser_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[hostile_laser]['image_paths']
]
self.hostile_laser_sound = pg.mixer.Sound(
animations_meta_data[hostile_laser]['sound'])
self.hostile_muzzle_images = [
pg.image.load(image_path) for image_path in
animations_meta_data[hostile_laser]['image_paths']
]
self.hostile_muzzle_spi = animations_meta_data[hostile_laser]['spi']
# load universal game animation attributes from meta data
# explosion
self.explosion_images = [
pg.image.load(image_path)
for image_path in animations_meta_data['explosion']['image_paths']
]
self.explosion_sound = pg.mixer.Sound(
animations_meta_data['explosion']['sound'])
self.explosion_spi = animations_meta_data['explosion']['spi']
# engine flame
self.engine_images = [
pg.image.load(image_path)
for image_path in animations_meta_data['engine']['image_paths']
]
self.engine_spi = animations_meta_data['engine']['spi']
# initialize empty sprite groups
self.all_ships = Group()
# player's groups
self.allied_ships = Group()
self.allied_laser_beams = Group()
# enemy groups
self.hostile_ships = Group()
self.hostile_laser_beams = Group()
# animation group
self.animations = Group()
# information displays
self.ship_stats = Group()
# create player sprite and add to relevant groups / provide with relevant groups
player = self.spawn_player(center=np.array([1400, 350]),
angle=180,
speed=250,
d_angle_degrees_per_second=150,
max_speed_pixel_per_second=360)
# create two wingmen
self.spawn_ai_squadron(
'allied',
centers=[np.array([1400, 100]),
np.array([1400, 700])],
angles=[180, 180],
speeds=[300, 300],
d_angle_degrees_per_seconds=[150, 150],
max_speed_pixel_per_seconds=[300, 300])
# create three enemies
self.spawn_ai_squadron('hostile',
centers=[
np.array([50, 100]),
np.array([50, 350]),
np.array([50, 700])
],
angles=[0, 0, 0],
speeds=[300, 300, 300],
d_angle_degrees_per_seconds=[150, 150, 150],
max_speed_pixel_per_seconds=[300, 300, 300])
# initialize enemy down time so that 2 enemies are spawned at beginning of game
hostile_down = False
ally_down = False
# initialize pause state variable
paused = False
# initiazlie sound toggle variable
sound = False
# start main game loop
while True:
# check for exit events
for event in pg.event.get():
if event.type == pg.QUIT:
# quit pygame
pg.quit()
sys.exit()
elif event.type == pg.KEYDOWN:
# toggle pause state if needed
if event.key == pg.K_ESCAPE:
paused = not paused
# toggle sound if needed
if event.key == pg.K_s:
sound = not sound
# update sprites if needed
for ship in self.all_ships.sprites():
ship._sound = sound
# control player fire mode
if event.key == pg.K_f:
player._toggle_fire_mode()
# control player fire commands
if event.key == pg.K_SPACE:
player._command_to_fire = True
# control player acceleration
if event.key == pg.K_UP:
player._d_speed += player._d_speed_pixel_per_frame
if event.key == pg.K_DOWN:
player._d_speed -= player._d_speed_pixel_per_frame
# control player steering
if event.key == pg.K_RIGHT:
player._d_angle -= player._d_angle_degrees_per_frame
if event.key == pg.K_LEFT:
player._d_angle += player._d_angle_degrees_per_frame
elif event.type == pg.KEYUP:
# control player fire commands
if event.key == pg.K_SPACE:
player._command_to_fire = False
# control player acceleration
if event.key == pg.K_UP:
player._d_speed -= player._d_speed_pixel_per_frame
if event.key == pg.K_DOWN:
player._d_speed += player._d_speed_pixel_per_frame
# control player steering
if event.key == pg.K_RIGHT:
player._d_angle += player._d_angle_degrees_per_frame
if event.key == pg.K_LEFT:
player._d_angle -= player._d_angle_degrees_per_frame
# spawn enemies if needed
if hostile_down:
# create first two enemy sprites and add to relevant groups / provide with relevant groups
self.spawn_hostile(center=np.array([50, 350]),
speed=300,
d_angle_degrees_per_second=150,
max_speed_pixel_per_second=300) # enemy #1
if ally_down:
# reanimate player
self.spawn_ally(center=np.array([1400, 350]),
speed=300,
angle=180,
d_angle_degrees_per_second=150,
max_speed_pixel_per_second=300)
if not paused:
# update game state
self.update_game_state()
# draw update game state to screen
self.draw_game_state()
# check and handle collisions
hostile_down, ally_down = self.handle_collisions()
# control pace
self.clock.tick(fps)
def run_game():
global bullets_die
pygame.init()
ai_settings = Settings()
stats = GameStats(ai_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()
alienbullets = Group()
play_button = Button(ai_settings, screen, 'Run!')
stats = GameStats(ai_settings)
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)
alien.rect.x = randint(0, ai_settings.screen_width)
alien.rect.y = randint(0, ai_settings.screen_height)
aliens.add(alien)
tre = 9
# print(alien.rect.y)
# create_alien(ai_settings,screen,aliens,alien_number,row_number)
# aliens.add(alien)
bg_color = (20, 250, 200)
while True:
if not stats.game_active:
play_button.draw_button()
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
#for alien in aliens.sprites():
if play_button.rect.collidepoint(mouse_x, mouse_y):
stats.game_active = True
if stats.game_active == True:
if tre == 1:
break
# print(alien.rect.y)
# tre = randint(-1000,1000)
# if tre == 1:
# alien.y = 0
# create_alien(ai_settings,screen,aliens,alien_number,row_number)
# if tre >= 990:
# bullets_die = False
# for row_number in range(number_rows):
# for alien_number in range(number_aliens_x):
# # print(alien.rect.y)
# create_alien(ai_se
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_8:
tre = 1
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:
stats.game_active = False
if event.key == pygame.K_RIGHT:
ship.movin_up = False
ship.movin_down = False
ship.movin_left = False
ship.movin_right = True
if event.key == pygame.K_UP:
ship.movin_up = True
ship.movin_down = False
ship.movin_left = False
ship.movin_right = False
if event.key == pygame.K_DOWN:
ship.movin_up = False
ship.movin_down = True
ship.movin_left = False
ship.movin_right = False
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_up = False
ship.movin_down = False
ship.movin_left = True
ship.movin_right = False
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
ship.rect.x = mouse_x
ship.rect.y = mouse_y
bullets.update()
ship.update()
# aliens.update()
ship.blitme()
alienbullets.update(bullets, aliens)
alienbullets.update(bullets, aliens)
ship.blitme()
pygame.display.flip()
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 = (0, 0, 0)
collisions = pygame.sprite.groupcollide(bullets, aliens,
bullets_die, True)
if len(aliens) == 0:
bullets.empty()
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
# print(alien.rect.y)
create_alien(ai_settings, screen, aliens, alien_number,
row_number)
ship.blitme()
bullets.update()
alien.blitme()
aliens.update()
if pygame.sprite.spritecollideany(ship, aliens):
if ai_settings.bullet_width >= ai_settings.width:
alien.rect.x = randint(0, ai_settings.screen_width)
alien.rect.y = randint(0, ai_settings.screen_height)
ai_settings.bullet_width += 10
ai_settings.bullet_height += 10
if ai_settings.bullet_width >= 300:
print('you win')
sys.exit()
ship.rect = pygame.Rect(ship.rect.x, ship.rect.y,
ai_settings.bullet_width,
ai_settings.bullet_height)
ai_settings.width = randint(1, 200)
alien.rect = pygame.Rect(alien.rect.x, alien.rect.y,
ai_settings.width, ai_settings.width)
if ai_settings.bullet_width < ai_settings.width:
alien.rect.x = randint(0, ai_settings.screen_width)
alien.rect.y = randint(0, ai_settings.screen_height)
ai_settings.bullet_width -= 10
ai_settings.bullet_height -= 10
ai_settings.width = randint(10, 200)
ship.rect = pygame.Rect(ship.rect.x, ship.rect.y,
ai_settings.bullet_width,
ai_settings.bullet_height)
alien.rect = pygame.Rect(alien.rect.x, alien.rect.y,
ai_settings.width, ai_settings.width)
if ai_settings.bullet_width <= 0:
print('you lose')
sys.exit()
# aliens.add(alien)
chek_fleet_edges(ai_settings, aliens)
#
pygame.display.flip()
class Game(object):
def __init__(self,
screen_width=1500,
screen_height=700,
fps=60,
background_image=None):
'''Initializes the game object and also the game'''
# initialize pygame (handles pretty much eveything)
pg.init()
# create clock
self.clock = pg.time.Clock()
self.background_image = pg.image.load(
'./graphics/misc/star_wars_background_24bit.bmp')
self.fps = fps
# initialize main screen
size = screen_width, screen_height # set screen size
self.screen = pg.display.set_mode(size)
# load meta data
with open('./meta/sprite_skins_meta_data.yaml',
'r') as skins_meta_file:
skins_meta_data = yaml.load(skins_meta_file)
with open('./meta/animations_meta_data.yaml',
'r') as animations_meta_file:
animations_meta_data = yaml.load(animations_meta_file)
# set player and enemy ship and laser types
allied_ship, allied_laser = 'tieinterceptor', 'green'
hostile_ship, hostile_laser = 'xwing', 'red'
# set game attributes from meta data for player
# skin specific
self.allied_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[allied_ship]['image_paths']
]
self.allied_gun_offsets = np.array(
skins_meta_data[allied_ship]['gun_offsets']).astype('float')
self.allied_engine_offsets = np.array(
skins_meta_data[allied_ship]['engine_offsets']).astype('float')
self.allied_fire_modes = skins_meta_data[allied_ship]['fire_modes']
# laser specific
self.allied_laser_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[allied_laser]['image_paths']
]
self.allied_laser_sound = pg.mixer.Sound(
animations_meta_data[allied_laser]['sound'])
self.allied_muzzle_images = [
pg.image.load(image_path)
for image_path in animations_meta_data[allied_laser]['image_paths']
]
self.allied_muzzle_spi = animations_meta_data[allied_laser]['spi']
# set game attributes from meta data for enemies
# behavioural
self.piloting_cone_sine = 0.1
self.gunning_cone_sine = 0.1
# skin specific
self.hostile_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[hostile_ship]['image_paths']
]
self.hostile_gun_offsets = np.array(
skins_meta_data[hostile_ship]['gun_offsets']).astype('float')
self.hostile_engine_offsets = np.array(
skins_meta_data[hostile_ship]['engine_offsets']).astype('float')
self.hostile_fire_modes = skins_meta_data[hostile_ship]['fire_modes']
# laser specific
self.hostile_laser_images = [
pg.image.load(image_path)
for image_path in skins_meta_data[hostile_laser]['image_paths']
]
self.hostile_laser_sound = pg.mixer.Sound(
animations_meta_data[hostile_laser]['sound'])
self.hostile_muzzle_images = [
pg.image.load(image_path) for image_path in
animations_meta_data[hostile_laser]['image_paths']
]
self.hostile_muzzle_spi = animations_meta_data[hostile_laser]['spi']
# load universal game animation attributes from meta data
# explosion
self.explosion_images = [
pg.image.load(image_path)
for image_path in animations_meta_data['explosion']['image_paths']
]
self.explosion_sound = pg.mixer.Sound(
animations_meta_data['explosion']['sound'])
self.explosion_spi = animations_meta_data['explosion']['spi']
# engine flame
self.engine_images = [
pg.image.load(image_path)
for image_path in animations_meta_data['engine']['image_paths']
]
self.engine_spi = animations_meta_data['engine']['spi']
# initialize empty sprite groups
self.all_ships = Group()
# player's groups
self.allied_ships = Group()
self.allied_laser_beams = Group()
# enemy groups
self.hostile_ships = Group()
self.hostile_laser_beams = Group()
# animation group
self.animations = Group()
# information displays
self.ship_stats = Group()
# create player sprite and add to relevant groups / provide with relevant groups
player = self.spawn_player(center=np.array([1400, 350]),
angle=180,
speed=250,
d_angle_degrees_per_second=150,
max_speed_pixel_per_second=360)
# create two wingmen
self.spawn_ai_squadron(
'allied',
centers=[np.array([1400, 100]),
np.array([1400, 700])],
angles=[180, 180],
speeds=[300, 300],
d_angle_degrees_per_seconds=[150, 150],
max_speed_pixel_per_seconds=[300, 300])
# create three enemies
self.spawn_ai_squadron('hostile',
centers=[
np.array([50, 100]),
np.array([50, 350]),
np.array([50, 700])
],
angles=[0, 0, 0],
speeds=[300, 300, 300],
d_angle_degrees_per_seconds=[150, 150, 150],
max_speed_pixel_per_seconds=[300, 300, 300])
# initialize enemy down time so that 2 enemies are spawned at beginning of game
hostile_down = False
ally_down = False
# initialize pause state variable
paused = False
# initiazlie sound toggle variable
sound = False
# start main game loop
while True:
# check for exit events
for event in pg.event.get():
if event.type == pg.QUIT:
# quit pygame
pg.quit()
sys.exit()
elif event.type == pg.KEYDOWN:
# toggle pause state if needed
if event.key == pg.K_ESCAPE:
paused = not paused
# toggle sound if needed
if event.key == pg.K_s:
sound = not sound
# update sprites if needed
for ship in self.all_ships.sprites():
ship._sound = sound
# control player fire mode
if event.key == pg.K_f:
player._toggle_fire_mode()
# control player fire commands
if event.key == pg.K_SPACE:
player._command_to_fire = True
# control player acceleration
if event.key == pg.K_UP:
player._d_speed += player._d_speed_pixel_per_frame
if event.key == pg.K_DOWN:
player._d_speed -= player._d_speed_pixel_per_frame
# control player steering
if event.key == pg.K_RIGHT:
player._d_angle -= player._d_angle_degrees_per_frame
if event.key == pg.K_LEFT:
player._d_angle += player._d_angle_degrees_per_frame
elif event.type == pg.KEYUP:
# control player fire commands
if event.key == pg.K_SPACE:
player._command_to_fire = False
# control player acceleration
if event.key == pg.K_UP:
player._d_speed -= player._d_speed_pixel_per_frame
if event.key == pg.K_DOWN:
player._d_speed += player._d_speed_pixel_per_frame
# control player steering
if event.key == pg.K_RIGHT:
player._d_angle += player._d_angle_degrees_per_frame
if event.key == pg.K_LEFT:
player._d_angle -= player._d_angle_degrees_per_frame
# spawn enemies if needed
if hostile_down:
# create first two enemy sprites and add to relevant groups / provide with relevant groups
self.spawn_hostile(center=np.array([50, 350]),
speed=300,
d_angle_degrees_per_second=150,
max_speed_pixel_per_second=300) # enemy #1
if ally_down:
# reanimate player
self.spawn_ally(center=np.array([1400, 350]),
speed=300,
angle=180,
d_angle_degrees_per_second=150,
max_speed_pixel_per_second=300)
if not paused:
# update game state
self.update_game_state()
# draw update game state to screen
self.draw_game_state()
# check and handle collisions
hostile_down, ally_down = self.handle_collisions()
# control pace
self.clock.tick(fps)
def update_game_state(self):
'''Updates the game state by updating all the game's sprite groups.'''
self.all_ships.update()
self.allied_laser_beams.update()
self.hostile_laser_beams.update()
self.animations.update()
self.ship_stats.update()
def draw_game_state(self):
'''Draws updated game state by wiping the game's main surface,
drawing all the game's sprite groups and then flipping the game's main
surface to display the drawings.'''
# draw new game state
self.screen.blit(self.background_image,
(0, 0)) # paint over old game state
self.all_ships.draw(self.screen) # draw all sprites
self.allied_laser_beams.draw(self.screen) # draw player lasers
self.hostile_laser_beams.draw(self.screen) # draw enemy lasers
self.animations.draw(self.screen) # draw animations
self.ship_stats.draw(self.screen) # draw frames and ship ids
# flip canvas
pg.display.flip()
def _sync_player_(self, player_sprite):
'''Takes a ShipSprite class object and syncs its _d_speed and _d_angle
attributes with the keyboard state. This is to avoid weird movement
when arrow keys are pressed while player is spawned.'''
pressed_keys = pg.key.get_pressed()
# sync player angle attributes
if pressed_keys[pg.K_LEFT]:
player_sprite._d_angle += player_sprite._d_angle_degrees_per_frame
if pressed_keys[pg.K_RIGHT]:
player_sprite._d_angle -= player_sprite._d_angle_degrees_per_frame
# sync player speed attributes
if pressed_keys[pg.K_UP]:
player_sprite._d_speed += player_sprite._d_speed_pixel_per_frame
if pressed_keys[pg.K_DOWN]:
player_sprite._d_speed -= player_sprite._d_speed_pixel_per_frame
def _get_id_image(self, ship_id, size=(50, 50)):
'''Takes the ship_id and makes and returns a pygame surface with that
ID in the bottom right corner.'''
largeText = pg.font.Font('freesansbold.ttf', 12)
textSurface = largeText.render(ship_id, True, (254, 254, 254))
return [textSurface]
def spawn_player(self,
ship_id="P",
center=np.array([900, 300]),
angle=0,
speed=200,
d_angle_degrees_per_second=150,
d_speed_pixel_per_second=10,
max_speed_pixel_per_second=400):
'''Creates a new PlayerShipSprite object and adds it to the game.'''
# create ship sprite object
player = ShipSprite(
self.fps,
self.screen,
self.allied_images,
self.allied_gun_offsets,
self.allied_fire_modes,
self.allied_laser_beams,
self.allied_laser_sound,
self.allied_laser_images,
1.2, # laser range in seconds
150, # laser speed in pixel per second
1.5, # laser rate of fire in seconds
self.allied_muzzle_images,
self.allied_muzzle_spi, # seconds per image for muzzle flash
self.explosion_sound, # sound of explosion animation
self.explosion_images,
self.
explosion_spi, # seconds per image for explosions animation at death
self.allied_engine_offsets,
self.engine_images,
self.engine_spi,
self.animations,
(self.allied_ships, self.all_ships),
center=center,
angle=angle,
speed=speed,
d_angle_degrees_per_second=d_angle_degrees_per_second,
d_speed_pixel_per_second=d_speed_pixel_per_second,
max_speed_pixel_per_second=max_speed_pixel_per_second)
# sync player controls with keyboard state
self._sync_player_(player)
# draw frame around player ship
TrackingAnimation(self.fps,
self.screen,
[pg.image.load("./graphics/misc/player_frame.bmp")],
10000,
player,
np.array([0, 0]).astype('float'),
self.ship_stats,
looping=True,
dynamic_angle=False)
# get ship_id display surface
ship_id_images = self._get_id_image(ship_id, (50, 50))
# draw ship id for hostile ship
TrackingAnimation(self.fps,
self.screen,
ship_id_images,
10000,
player,
np.array([15, 25]).astype('float'),
self.ship_stats,
looping=True,
dynamic_angle=False)
return player
def spawn_ally(self,
ship_id,
center=np.array([1200, 500]),
angle=180,
speed=200,
d_angle_degrees_per_second=150,
d_speed_pixel_per_second=10,
max_speed_pixel_per_second=350):
'''Creates a new allied AIShipSprite and adds it to the game.'''
# spawn AI controlled allied ship sprite
ally = AIShipSprite(
self.fps,
self.screen, # main screen
self.allied_images, # sequence with ShipSprite's skin
self.allied_gun_offsets,
self.allied_fire_modes, #
self.allied_laser_beams,
self.allied_laser_sound, # pygame sound object; laser fire sound
self.allied_laser_images, # sequence with laser beam skin
1.2,
150,
1.5, # laser rate of fire in shots/second
self.
allied_muzzle_images, # sequence of images for muzzle flash animation
self.
allied_muzzle_spi, # seconds per image for muzzle flash animation
self.explosion_sound,
self.explosion_images,
self.explosion_spi,
self.allied_engine_offsets,
self.engine_images,
self.engine_spi,
self.animations,
#player,
self.piloting_cone_sine,
self.gunning_cone_sine,
(self.allied_ships, self.all_ships),
hostile_ships_group=self.
hostile_ships, # group of hostile ships sprites
center=center,
angle=angle,
speed=speed,
d_angle_degrees_per_second=d_angle_degrees_per_second,
d_speed_pixel_per_second=d_speed_pixel_per_second,
max_speed_pixel_per_second=max_speed_pixel_per_second)
# draw frame around ally ship
TrackingAnimation(self.fps,
self.screen,
[pg.image.load("./graphics/misc/ally_frame.bmp")],
10000,
ally,
np.array([0, 0]).astype('float'),
self.ship_stats,
looping=True,
dynamic_angle=False)
# get ship_id display surface
ship_id_images = self._get_id_image(ship_id)
# draw ship id for hostile ship
TrackingAnimation(self.fps,
self.screen,
ship_id_images,
10000,
ally,
np.array([15, 15]).astype('float'),
self.ship_stats,
looping=True,
dynamic_angle=False)
def spawn_hostile(self,
ship_id,
center=np.array([1200, 50]),
angle=0,
speed=200,
d_angle_degrees_per_second=150,
d_speed_pixel_per_second=10,
max_speed_pixel_per_second=350):
'''Creates a new hostile AIShipSprite and adds it to the game.'''
# spawn hostile AI controlled ship sprite
hostile = AIShipSprite(
self.fps,
self.screen, # main screen
self.hostile_images, # sequence with ShipSprite's skin
self.hostile_gun_offsets,
self.hostile_fire_modes, #
self.hostile_laser_beams,
self.hostile_laser_sound, # pygame sound object; laser fire sound
self.hostile_laser_images, # sequence with laser beam skin
1.2,
150,
1.5, # laser rate of fire in shots/second
self.
hostile_muzzle_images, # sequence of images for muzzle flash animation
self.
hostile_muzzle_spi, # seconds per image for muzzle flash animation
self.explosion_sound,
self.explosion_images,
self.explosion_spi,
self.hostile_engine_offsets,
self.engine_images,
self.engine_spi,
self.animations,
#player,
self.piloting_cone_sine,
self.gunning_cone_sine,
(self.hostile_ships, self.all_ships),
hostile_ships_group=self.
allied_ships, # group of hostile ships sprites
center=center,
angle=angle,
speed=speed,
d_angle_degrees_per_second=d_angle_degrees_per_second,
d_speed_pixel_per_second=d_speed_pixel_per_second,
max_speed_pixel_per_second=max_speed_pixel_per_second)
# draw frame around hostile ship
TrackingAnimation(self.fps,
self.screen,
[pg.image.load("./graphics/misc/hostile_frame.bmp")],
10000,
hostile,
np.array([0, 0]).astype('float'),
self.ship_stats,
looping=True,
dynamic_angle=False)
# get ship_id display surface
ship_id_images = self._get_id_image(ship_id)
# draw ship id for hostile ship
TrackingAnimation(self.fps,
self.screen,
ship_id_images,
10000,
hostile,
np.array([20, 20]).astype('float'),
self.ship_stats,
looping=True,
dynamic_angle=False)
def spawn_ai_squadron(self, side, centers, angles, speeds,
d_angle_degrees_per_seconds,
max_speed_pixel_per_seconds):
'''Util function to spawn a group of allied or hostile ships. Usually
used at beginning of game.'''
ship_id_counter = 1 # counter
ship_id_tail = side[0].upper() # initial of side
for center, angle, speed, d_angle, max_speed in zip(
centers, angles, speeds, d_angle_degrees_per_seconds,
max_speed_pixel_per_seconds):
ship_id = str(ship_id_counter) + ship_id_tail
if side == 'allied':
self.spawn_ally(ship_id,
center=center,
angle=angle,
speed=speed,
d_angle_degrees_per_second=d_angle,
max_speed_pixel_per_second=max_speed)
elif side == 'hostile':
self.spawn_hostile(ship_id,
center=center,
angle=angle,
speed=speed,
d_angle_degrees_per_second=d_angle,
max_speed_pixel_per_second=max_speed)
ship_id_counter += 1
def handle_collisions(self):
'''Checks for collisions between player sprite and enemy lasers, as well
as enemy sprites and player lasers. Terminates any sprites that were
shot down. Records the time of the kill.'''
ally_down = False
hostile_down = False
# check for enemy kills
hit_allies = groupcollide(self.allied_ships, self.hostile_laser_beams,
False, True, collide_mask)
for hit_ally in hit_allies:
# update hit ship's hit points attribute
hit_ally._hit_points -= 1
# if ship has no more hit points left, destroy and set flag
if not hit_ally._hit_points:
hit_ally.kill()
#ally_down = True
# check for player kills
hit_hostiles = groupcollide(self.hostile_ships,
self.allied_laser_beams, False, True,
collide_mask)
for hit_hostile in hit_hostiles:
# update hit ship's hit points attribute
hit_hostile._hit_points -= 1
# if ship has no more hit points left, destroy and flag
if not hit_hostile._hit_points:
hit_hostile.kill()
#hostile_down = True
return hostile_down, ally_down
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, 38)
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
#得分转换为图像
round_score = 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)
#置于左上角
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.ai_settings.bg_color)
#置于中间
self.high_score_rect = self.score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = 20
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.screen_rect.right - 20
self.level_rect.top = self.level_rect.bottom + 30
def prep_ships(self):
#显示剩余飞船
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 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 = (255, 255, 255)
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()
def prep_score(self):
"""Turn the score into a rendered image."""
#score_str = str(self.stats.score)
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 show_score(self):
"""Draw scores, 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 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 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()
self.prep_level()
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 run_game():
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.mixer.init()
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
ship = Ship(ai_settings, screen)
stats = GameStats(ai_settings)
hud = Hud(ai_settings, screen, stats, ship)
play_button = Button(screen, "Start")
bullets = Group()
aliens = Group()
alien_bullets = Group()
health = Group()
ammo = Group()
used_shields = Group()
bosses = GroupSingle()
boss_shields = GroupSingle()
clock = pygame.time.Clock()
boss_bullets = Group()
black_holes = GroupSingle()
ai_settings.state = ai_settings.running
# Main game cycle.
while True:
dt = clock.tick()
gf.check_events(ai_settings, screen, stats, hud, play_button, ship,
aliens, bullets, used_shields)
gf.check_keys_pressed(ship)
if ai_settings.state == ai_settings.running:
if stats.game_active:
ship.update()
gf.update_ship_shield(ship, alien_bullets, used_shields,
boss_bullets)
gf.update_bullets(ai_settings, screen, stats, hud, ship,
aliens, bullets, alien_bullets, health, ammo,
bosses, boss_bullets, boss_shields,
black_holes)
gf.update_aliens(ai_settings, screen, stats, hud, ship, aliens,
bullets, alien_bullets, health, ammo,
used_shields)
gf.fire_alien_bullets(ai_settings, screen, stats, ship, aliens,
alien_bullets, dt)
gf.update_alien_bullets(ai_settings, screen, stats, hud, ship,
aliens, bullets, alien_bullets, health,
ammo, used_shields)
if stats.stage == ai_settings.boss_stages[0]:
gf.update_green_boss(ai_settings, screen, stats, hud, ship,
bullets, used_shields, bosses,
boss_bullets, boss_shields, bosses)
gf.fire_green_boss_bullets(ai_settings, screen, dt, bosses,
boss_bullets)
gf.update_green_boss_bullets(ai_settings, screen, stats,
hud, ship, bullets,
used_shields, bosses,
boss_bullets, boss_shields,
black_holes)
gf.update_green_boss_shield(hud, bullets, boss_shields)
elif stats.stage == ai_settings.boss_stages[1]:
gf.update_red_boss(ai_settings, screen, stats, hud, ship,
bullets, used_shields, bosses,
boss_bullets, boss_shields, black_holes)
gf.update_red_boss_shield(hud, bullets, boss_shields)
gf.fire_red_boss_bullets(ai_settings, screen, ship, dt,
bosses, boss_bullets)
gf.update_red_boss_bullets(ai_settings, screen, stats, hud,
ship, bullets, used_shields,
bosses, boss_bullets,
boss_shields, black_holes)
elif stats.stage == ai_settings.boss_stages[2]:
gf.update_blue_boss(ai_settings, screen, stats, hud, ship,
bullets, used_shields, bosses,
boss_bullets, boss_shields,
black_holes)
gf.update_blue_boss_shield(hud, bullets, boss_shields)
gf.fire_blue_boss_bullets(ai_settings, screen, dt, bosses,
boss_bullets)
gf.update_blue_boss_bullets(ai_settings, screen, stats,
hud, ship, bullets,
used_shields, bosses,
boss_bullets, boss_shields,
black_holes)
gf.create_black_hole(ai_settings, screen, ship, dt,
black_holes)
gf.update_black_hole(ai_settings, screen, stats, hud, ship,
bullets, used_shields, dt, bosses,
boss_bullets, boss_shields,
black_holes)
gf.update_ship_health(stats, hud, ship, health)
gf.update_ship_ammo(stats, hud, ship, ammo)
elif ai_settings.state == ai_settings.paused:
pass
if ai_settings.state == ai_settings.running:
gf.update_screen(ai_settings, screen, stats, hud, ship, aliens,
bullets, alien_bullets, play_button, health, ammo,
used_shields, dt, bosses, boss_bullets,
boss_shields, black_holes)
else:
pass
class Scoreboard():
"""A class to report scoring information"""
def __init__(self, ai_settings, screen, stats):
"""Initialise 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, 48)
#Prepare the initial 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"""
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_colour)
#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 = 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_colour)
#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.screen_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_colour)
#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_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 the 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)
