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)
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
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):
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)
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 ExplorableScreen(GameScreen):
def __init__(self, config, model):
super(ExplorableScreen, self).__init__(config, model)
def setup(self):
super(ExplorableScreen, self).setup()
pastel_flowers = Image(os.path.join("sample_sprites", "tiles", "png", "pastel_flowers.png"))
grass = Image(os.path.join("sample_sprites", "tiles", "png", "grass.png"))
images = (pastel_flowers, grass)
# XXX Just a demo, do not try this at home: this (rightly!) assumes that
# pastel_flowers and grass have the same dimensions
visible_width = int(self.screen_dimensions[GameConfig.WIDTH_INDEX] / pastel_flowers.width)
visible_height = int(self.screen_dimensions[GameConfig.HEIGHT_INDEX] / pastel_flowers.height)
area_tile_size = (visible_width + 2) * (visible_height + 2)
self.tiles = Group()
for i in range(area_tile_size):
img = random.choice(images)
img_xpos = img.width * (i % visible_width)
img_ypos = img.height * (i % visible_height)
self.tiles.add(PyRoSprite(img.clone((img_xpos, img_ypos))))
def draw_screen(self, window):
self.tiles.draw(window)
self.tiles.update()
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 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
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 _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
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 create_shield(settings, screen, number): """Create and return a group of blocks that make up a single shield.""" shield_blocks = Group() for row in range(settings.shield_rows): for column in range(settings.shield_columns): if settings.shield_array[row][column] == 'b': new_block = Block(settings, screen, settings.green, settings.shield_x + (132 * number + number * 3) + (column * settings.block_size), settings.shield_y + (row * settings.block_size)) shield_blocks.add(new_block) return shield_blocks
def create_ground(settings, screen): """Create a ground line under player.""" ground_blocks = Group() # Calculate how many blocks fit on the screen and create them. for column in range(int((settings.screen_width / settings.block_size) - int((settings.ground_offsetx * 2) / settings.block_size))): block = Block(settings, screen, settings.green, settings.ground_offsetx + settings.block_size * column, settings.ground_y) ground_blocks.add(block) return ground_blocks
def create_invader_shot_explosion(self, settings, screen, x, y): """Create and return explosion "sprite" as a group of Blocks. Top-left point of group is set to x, y.""" explode_blocks = Group() for row in range(settings.invader_shot_explode_rows): for column in range(settings.invader_shot_explode_columns): if settings.invader_shot_explode_array[row][column] == 'b': new_block = Block(settings, screen, settings.white, x + (column * settings.block_size), y + (row * settings.block_size)) explode_blocks.add(new_block) return explode_blocks
def build(self, data):
rows = len(data)
cols = len(data[0])
tiles = Group()
for y, row in enumerate(data):
for x, cell in enumerate(row):
data = self.tilemap.get(cell)
if data:
tile = Tile(cell, data["image"], (x*self.w, y*self.h), data["collides"])
tiles.add(tile)
return tiles, (cols * self.w, rows * self.h)
class VerticalToolbar(pygame.sprite.Sprite):
def __init__(self, editor_level, font_manager):
pygame.sprite.Sprite.__init__(self)
self.editor_level = editor_level
self.selected = None
self.position = Point(constants.HORIZONTAL_TILES, 0)
self.width = editor_constants.RIGHT_BAR_RATIO
self.height = constants.VERTICAL_TILES
self.options = Group()
self.hotkeys = {}
top = editor_constants.RIGHT_BAR_ITEM_SPACING
for (name, data) in editor_constants.ENTITY_DATA:
option = ToolbarOption(top, name, data, font_manager)
if self.selected is None:
self.select(option)
self.options.add(option)
top += editor_constants.RIGHT_BAR_ITEM_RATIO + editor_constants.RIGHT_BAR_ITEM_SPACING
self.hotkeys[data.hotkey] = option
self.update_graphics()
def hotkey(self, hotkey):
if hotkey in self.hotkeys:
self.select(self.hotkeys[hotkey])
def select(self, option):
if self.selected is not None:
self.selected.toggle_select()
self.selected = option
self.selected.toggle_select()
self.editor_level.entity_to_create = option.name
def left_click(self, position, pressed):
for option in self.options:
rect = pygame.Rect(option.position.scale(constants.TILE_SIZE), (constants.TILE_SIZE * option.size, constants.TILE_SIZE * option.size))
if rect.collidepoint(position.scale(constants.TILE_SIZE)):
self.select(option)
def update_graphics(self):
width = int(round(self.width * constants.TILE_SIZE))
height = int(round(self.height * constants.TILE_SIZE))
self.image = pygame.Surface([width, height])
self.image.fill(editor_constants.TOOLBAR_COLOR)
self.rect = self.image.get_rect(topleft=self.position.scale(constants.TILE_SIZE))
def draw(self, screen):
self.options.draw(screen)
class Logo:
"Escena que muestra el logotipo del grupo losersjuegos."
def __init__(self, world):
self.world = world
self.sprites = Group()
self._create_sprites()
self._reset_timer()
def _reset_timer(self):
self.time_out = 50
def update(self):
key = pygame.key.get_pressed()
if key[pygame.K_ESCAPE]:
self.world.state = Logo(self.world)
self._reset_timer()
return
else:
self.sprites.update()
if self.time_out < 1 or key[pygame.K_RETURN]:
self.world.change_state(scenes.mainmenu.MainMenu(self.world))
self.time_out -= 1
def draw(self, screen):
screen.fill((92, 123, 94))
self.sprites.draw(screen)
pygame.display.flip()
def _create_sprites(self):
steps = [0, 0, 0, 1, 2, 3, 4]
losers = SimpleAnimation('logo', 'losers_5.png', steps, 2)
sprite_losers = LogoSpriteAnimated(losers, LEFT, 190, 190)
steps2 = [0, 0, 0, 1, 2, 3, 4]
juegos = SimpleAnimation('logo', 'juegos_5.png', steps2, 2)
sprite_juegos = LogoSpriteAnimated(juegos, RIGHT, 390, 190)
steps3 = [0, 0, 0, 1, 1, 2, 3]
ceferino = SimpleAnimation('logo', 'ceferino_4.png', steps3, 2)
sprite_ceferino = LogoSpriteAnimated(ceferino, RIGHT, 40, 160)
self.sprites.add([sprite_juegos, sprite_losers, sprite_ceferino])
def handle_event(self, event):
pass
def freebie(self):
groupus = Group()
groupus.add(self.blackHoles,self.goal)
self.player.makeANew = True
self.player.addTail = False
while True:
self.clock.tick(self.fps)
pygame.draw.rect(self.screen,(0,0,0),((0,0),(1000,750)))
for evt in pygame.event.get():
if evt.type == QUIT:
self.quit()
if evt.type == KEYDOWN:
if evt.key == K_ESCAPE:
self.quit()
for obj in self.blackHoles:
if pygame.sprite.collide_mask(self.player,obj):
self.player.blackHoleCollision(True,False)
for obj in self.masslessObstacles:
if pygame.sprite.collide_mask(self.player,obj):
self.player.update(True)
for obj in self.userPlacedObjects:
if pygame.sprite.collide_mask(self.player,obj) and not obj.grabbed:
self.player.update(True)
self.startItems.update()
#self.masslessObstacles.update()
self.stars.draw()
self.player.drawTails()
self.goalCollide.draw(self.screen)
self.masslessObstacles.draw(self.screen)
self.userPlacedObjects.draw(self.screen)
self.toolbar.draw(self.screen)
self.blackHoles.draw(self.screen)
self.player.update(False,groupus)
self.playerGroup.draw(self.screen)
self.startItems.draw(self.screen)
if len(self.playerGroup) < 1:
self.player.addTail = True
pygame.time.wait(750)
self.player.add(self.playerGroup)
break
pygame.display.flip()
class WvmSpritesList():
"""A class listing all the Sprites of the game."""
def __init__(self, config, screen):
"""Initialize the sprite list."""
self.config = config
self.screen = screen
#initialize the sprites
self.wiz = Wizard(config, self)
self.monsters = Group()
self.missiles = Group()
def update_all(self):
"""Update the positions of all sprites."""
self.update_missiles()
self.wiz.update()
self.monsters.update()
def update_missiles(self):
"""update magic missiles positions"""
self.missiles.update()
# remove the missiles that have left the screen
for mi in self.missiles.copy():
if mi.rect.left >= self.screen.get_rect().right:
self.missiles.remove(mi)
def draw(self):
self.screen.fill(self.config.bg_color)
for mi in self.missiles:
mi.draw_missile()
self.wiz.blitme()
for mo in self.monsters:
mo.blitme()
def fire_missile(self):
"""Fire a missile if limit not reached yet."""
if len(self.missiles) < self.wiz.magic_missile_allowed:
self.missiles.add(MagicMissile(self.config, self))
def create_monster(self):
"""Create a new monster and place it randomly at the right."""
monster=Monster(self.config, self)
#TODO move the monster
self.monsters.add(monster)
def game():
# init
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
clock = pygame.time.Clock()
dude = PlayerShip(260, 500, screen.get_rect())
dude_grp = GroupSingle(dude)
enemies = Group()
enemies.add(Burger(200, 200, screen.get_rect()))
enemies.add(Hotdog(100, 100, screen.get_rect()))
#loop
while True:
# input
for evt in pygame.event.get():
if evt.type == QUIT:
return
elif evt.type == KEYDOWN and evt.key == K_ESCAPE:
return
elif evt.type == KEYDOWN and evt.key == K_a:
dude.dx = -10
elif evt.type == KEYDOWN and evt.key == K_d:
dude.dx = 10
elif evt.type == KEYUP and evt.key == K_a and dude.dx == -10:
dude.dx = 0
elif evt.type == KEYUP and evt.key == K_d and dude.dx == 10:
dude.dx = 0
elif evt.type == KEYDOWN and evt.key == K_SPACE and dude.alive():
dude.shoot()
# update
clock.tick(FPS)
dude.update()
enemies.update()
dude.bullets.update()
pygame.sprite.groupcollide(enemies, dude.bullets, 1, 1)
pygame.sprite.groupcollide(dude_grp, enemies, 1, 0)
# draw
screen.fill(BLACK)
dude_grp.draw(screen)
enemies.draw(screen)
dude.bullets.draw(screen)
pygame.display.flip()
class Scene(object):
def __init__(self, screen):
"""Create the scene's objects."""
self.screen = screen
self.running = True
# Groups for sprites
self.players = Group()
self.enemies = Group()
self.chars = Group()
self.weapons = Group()
self.projs = Group()
self.all = LayeredDirty()
# Room
self.room = Room(self)
self.all.add(self.room)
# Weapons
self.weapon_list = [ LaserGun(self), Bow(self) ]
for weapon in self.weapon_list:
self.weapons.add(weapon)
# Players
self.player = Player(self)
self.players.add(self.player)
self.all.add(self.players)
# Enemies
enemy_list = [ Human, Glork ]
for enemy in range(0, randint(50,100)):
self.enemies.add(choice(enemy_list)(self))
self.all.add(self.enemies)
# Characters
self.chars.add([self.players, self.enemies])
# Layers
self.all = LayeredDirty([
self.room,
self.enemies,
self.players,
self.weapons,
self.projs ])
def draw(self):
"""Draw all of the objects to the screen."""
# Update all scene layers to the screen.
self.all.update()
self.dirty_rects = self.all.draw(self.screen)
display.update(self.dirty_rects)
class Board:
def __init__(self, width: int, height: int):
super().__init__()
self.width = width
self.height = height
self.players = Group()
self.walls = Group()
for w in range(width >> 1):
for h in range(height >> 1):
wall = Wall()
wall.rect.x = PPM * (2 * w + 1)
wall.rect.y = PPM * (2 * h + 1)
self.walls.add(wall)
def draw(self, canvas):
self.walls.draw(canvas)
self.players.draw(canvas)
def update(self, dt):
self.players.update(dt)
def test(sett, screen):
pepe = pygame.image.load('pepe.png')
borrito = pygame.image.load('borrito.png')
test_dia = Dialogue(sett, screen, "right", "", pepe)
test_dia2 = Dialogue(sett,screen, "left", "", borrito)
dials = Group()
dials.add(test_dia)
dials.add(test_dia2)
backwards = False
while True:
gf.events()
if not sett.paused:
test_dia.update(backwards)
test_dia2.update(backwards)
print(test_dia2.x)
if test_dia.x == 100:
##test dialogue. TODO have file of encounters to refer to
gf.update_screen(sett, screen, True, dials,"i am here to slay",173,255,47)
pygame.time.wait(3000)
gf.update_screen(sett, screen, True, dials,"prepare urself",173,255,47)
pygame.time.wait(3000)
gf.update_screen(sett, screen, True, dials,"no way",255,69,0)
pygame.time.wait(3000)
backwards = True
#test_dia.x = test_dia.x -1 #back()
#test_dia2.x= test_dia2.x +1 #back()
if test_dia.x < -200:
del test_dia
if test_dia2.x > 800:
del test_dia2
dials.empty()
gf.update_screen(sett, screen, True, dials)
class UI:
def __init__(self):
self.tiles = Group()
self.bg = []
self.tntcrate = TNTCrate()
self.tiles.add(Grass(96 * gl.RESIZE_FACTOR, 176 * gl.RESIZE_FACTOR, 64 * gl.RESIZE_FACTOR, 16 * gl.RESIZE_FACTOR))
self.tiles.add(Grass(32 * gl.RESIZE_FACTOR, 64 * gl.RESIZE_FACTOR, 32 * gl.RESIZE_FACTOR, 16 * gl.RESIZE_FACTOR))
self.tiles.add(Grass(192 * gl.RESIZE_FACTOR, 64 * gl.RESIZE_FACTOR, 32 * gl.RESIZE_FACTOR, 16 * gl.RESIZE_FACTOR))
self.tiles.add(Grass(32 * gl.RESIZE_FACTOR, 224 * gl.RESIZE_FACTOR, 32 * gl.RESIZE_FACTOR, 16 * gl.RESIZE_FACTOR))
self.tiles.add(Grass(192 * gl.RESIZE_FACTOR, 224 * gl.RESIZE_FACTOR, 32 * gl.RESIZE_FACTOR, 16 * gl.RESIZE_FACTOR))
for i in xrange(0, 50):
self.bg.append(Star())
self.bg.append(self.tntcrate)
def update(self, tick):
pass
class PlayerShip(Sprite):
def __init__(self, x, y, bounds):
Sprite.__init__(self)
self.image, self.rect = ld_pics('ship.bmp')
self.rect.x = x
self.rect.y = y
self.dx = 0
self.dy = 0
self.bounds = bounds
self.bullets = Group()
def shoot(self):
bullet = Bullet(self.rect.x, self.rect.y, self.bounds)
self.bullets.add(bullet)
def update(self):
self.rect.x += self.dx
self.rect.y += self.dy
if self.rect.left < self.bounds.left:
self.rect.left = self.bounds.left
if self.rect.right > self.bounds.right:
self.rect.right = self.bounds.right
def __init__(self, target, sprite_filename, formation, target_position):
Group.__init__(self)
self.target = target
self.sprite_filename = sprite_filename
self.target_position = target_position
#this image is passed to each Cell object
cell_image = pygame.image.load(sprite_filename).convert_alpha()
#convert formation list into table of cell sprites
#offsets are the difference between current cell and target cell
#since first cell is (0, 0) these start as negative of the target
row_offset = -target_position[0]
cells = []
for row in formation:
col_offset = -target_position[1]
cells_row = []
for col in row:
#0 means the cell is empty
if col == 0:
cells_row.append(None)
#1 means a cell sprite should be added here
elif col == 1:
new_cell = Cell(row_offset, col_offset, cell_image, target)
Group.add(self, new_cell)
cells_row.append(new_cell)
#anything else means wtf are you doing
else: raise
col_offset += 1
cells.append(cells_row)
row_offset += 1
self.cells = cells
self.delay = 0
class Game(ApplicationState):
foo = "foo"
def setup (self):
self.SCREEN_SIZE = SCREEN_SIZE
self.BG_COLOR = BG_COLOR
self.score = 0
self.spawntime = 10
self.spawnticker = 0
self.robot_grp = Group()
ImpactGroup.impacts = Group()
ShieldGroup.shields = Group()
self.bounds = self.app.screen.get_rect()
self.font = pygame.font.Font(None,35)
self.player = Player(self.bounds.center, self.bounds) #sets starting position fir player
robot = Robot((randrange(0,800),randrange(0,600)), self.bounds)
self.player_grp = GroupSingle(self.player)
#robot_grp = GroupSingle(robot)
self.robot_grp.add(Robot((randrange(0,800),randrange(0,600)), self.bounds))
self.robot_grp.add(Brotherbot((randrange(0,800),randrange(0,600)), self.bounds))
self.robot_grp.add(Fatherbot((randrange(0,800),randrange(0,600)), self.bounds))
self.meteors = Group()
self.impacts = Group()
#game loop
def handle_event(self, event):
if event.type == KEYDOWN and event.key == K_ESCAPE:
self.app.set_state(PauseMenu)
elif event.type == KEYDOWN and event.key == K_SPACE and not self.is_gameover():
if self.player.carrying:
self.player.drop()
else:
for robot in groupcollide(self.robot_grp, self.player_grp, False, False):
self.player.grab(robot)
self.score += 50
print "robot picked up"
def load_image(name, colorkey=None):
fullname = os.path.join('resources', name)
try:
image = pygame.image.load(fullname)
except pygame.error, message:
print "Cant load yo image:", name
raise SystemExit, message
image = image.convert()
if colorkey is not None:
if colorkey is -1:
colorkey = image.get_at((0,0))
image.set_colorkey(colorkey, RLEACCEL)
return image, image.get_rect()
class InvadersGame:
def __init__(self):
self.game = Game()
floorframe = Frame(self.game.screen, Rect(0, 542, MAX_X + 36, 596))
self.floor = TiledMap(self.game, floorframe)
self.floor.fill_map('#', (25, 2))
self.player = Player(self.game)
self.aliens = Group()
self.create_aliens()
self.shots = Group()
self.alien_shots = Group()
def create_aliens(self):
for i in range(4):
for j in range(20):
direction = [LEFT, RIGHT][i % 2]
alien = Alien(self.game, Vector(j * 32 + 32, i * 64), direction)
self.aliens.add(alien)
def shoot(self):
shot = self.player.get_shot()
self.shots.add(shot)
def draw(self):
self.game.screen.clear()
self.player.draw()
self.shots.draw(self.game.screen.display)
self.alien_shots.draw(self.game.screen.display)
self.aliens.draw(self.game.screen.display)
self.floor.draw()
def update(self):
self.player.move()
self.shots.update()
self.alien_shots.update()
self.aliens.update()
for a in self.aliens:
shot = a.get_shot()
if shot:
self.alien_shots.add(shot)
self.draw()
groupcollide(self.shots, self.aliens, True, True, collided=collide_mask)
if spritecollideany(self.player, self.alien_shots, collided=collide_mask):
self.game.exit()
if not self.aliens:
self.game.exit()
def run(self):
self.game.event_loop(figure_moves=self.player.set_direction,
draw_func=self.update, keymap={K_SPACE: self.shoot}, delay=30)
class Level(object):
def __init__(self, name):
self.bounds = Rect((0,0,), LEVEL_SIZE)
self.blocks = Group()
self.lethal = Group()
self.win = Group()
self.loadData(name)
self.spawnPoint = (20,20)
self.render_background()
def render_background(self):
self.background = Surface(self.bounds.size)
self.background.fill((0,0,0))
self.blocks.draw(self.background)
self.lethal.draw(self.background)
self.win.draw(self.background)
def loadData(self, name):
ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(ROOT_DIR, 'data')
path = os.path.join(DATA_DIR, name) + '.lvl'
with open(path, 'r') as f:
data = f.read().strip().split('\n')
width = 20
height = 20
for y, row in enumerate(data):
for x,c in enumerate(row):
loc = (x*width, y*height)
if c == '.':
self.blocks.add(Block(loc))
elif c == '!':
self.lethal.add(Lethal(loc))
elif c == "^":
self.win.add(Win(loc))
class Scoreboard:
"""显示得分信息的类"""
def __init__(self, ai_settings, screen, stats):
"""初始化显示得分信息涉及的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# 显示得分信息所需的字体设置
self.text_color = (190, 25, 125)
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取就近10的整数倍, 并以 , 格式化数字
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# 将得分信息显示在屏幕右上角
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_high_score(self):
"""将最高得分转换为渲染的图像"""
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.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def show_score(self):
"""在屏幕上显示飞船和得分"""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
# 绘制飞船
self.ships.draw(self.screen)
def 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)
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 = (255, 255, 255)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score images.
self.prep_score()
self.prep_high_score(stats)
self.prep_level()
self.prep_ships()
self.score_rect = self.score_image.get_rect()
self.high_score_image = self.font.render("HIGH SCORE: ", True,
self.text_color,
self.ai_settings.bg_color)
self.ships = Group()
self.high_score_rect = self.high_score_image.get_rect()
self.level_image = self.font.render("LEVEL: ", True, self.text_color,
self.ai_settings.bg_color)
self.level_rect = self.level_image.get_rect()
self.score_image = self.font.render("SCORE: ", True, self.text_color,
self.ai_settings.bg_color)
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: " + 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, stats):
"""Turn the high score into a rendered image."""
high_score1 = int(round(self.stats.high_score, -1))
high_score2 = stats.current
if high_score1 > high_score2:
high_score = high_score1
else:
high_score = high_score2
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(
"HIGH SCORE: " + 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."""
self.level_image = self.font.render("LEVEL: " + str(self.stats.level),
True, self.text_color,
self.ai_settings.bg_color)
# Position the level below the score.
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.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 + 10)
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
"""Draw score to the screen."""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
# Draw ships.
self.ships.draw(self.screen)
class Scoreboard:
"""A class to report scoring information"""
def __init__(self, ai_game):
"""Initialize scorekeeping attributes"""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# Font settings for scoring information
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prepare the initial score image
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
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 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 high score at top of 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()
def prep_level(self):
"""Turn level into 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 level below 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():
# 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)
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)
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()
enemy_bullets.update()
# remove bullets outside of the screen
for i in player_bullets.copy():
if not i.rect.colliderect(screenRect):
class Scoreboard:
"""显示得分信息的类"""
def __init__(self, ai_game):
"""初始化显示得分涉及的属性。"""
self.ai_game = ai_game
self.screen = ai_game.screen
self.screen_rect = self.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
# 显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# 准备初始得分图像
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
"""显示还余下多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_level(self):
"""将等级转换为渲染的图像。"""
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.bg_color)
# 将等级放在得分下方
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10
def prep_score(self):
"""将得分转换为一幅渲染的图像。"""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.bg_color)
# 在屏幕右上角显示得分
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_high_score(self):
"""将最高得分转换为渲染的图像。"""
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.bg_color)
# 将最高得分放在屏幕顶部中央。
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def show_score(self):
"""在屏幕上绘制得分、等级和余下的飞船数。"""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
def check_high_score(self):
"""检查是否诞生了新的最高分。"""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
class 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 image."""
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""Turn the score into a renderd image."""
round_score = round(self.stats.score, -1)
# https://www.w3schools.com/python/ref_string_format.asp
score_str = "{:,}".format(round_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 score, 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()
def write_high_score_to_file(self):
with open("All_Time_High_Score.txt", 'r') as f:
high_score_in_file = int(f.read())
with open("All_Time_High_Score.txt", 'w') as f:
if self.stats.high_score > high_score_in_file:
f.write(str(self.stats.score))
# if not add this else condition, the file will be empty when you directly quit the game without gain a point.
else:
f.write(str(high_score_in_file))
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 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 run_game():
global ch
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()
alienbullets = Group()
run = 1
alien = Alien(ai_settings, screen, alienBullet, alienbullets)
bg_color = (20, 250, 200)
but = Button(ai_settings, screen, ship, aliens, bullets, alien)
#bullets.add(but)
but.rect.x = 0
but.rect.y = 0
but2 = Button(ai_settings, screen, ship, aliens, bullets, alien)
but2.rect.x = 0
solds = Group()
but2.rect.y = 200
but2.image = pygame.image.load('tree.gif')
it = 0
while True:
tre = randint(50, 100)
if tre == 71:
alien = Alien(ai_settings, screen, alienbullets, alienBullet)
aliens.add(alien)
alien.rect.x = randint(0, ai_settings.screen_width - 30)
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_s:
run = 1
if event.key == pygame.K_b:
sys.exit()
if event.key == pygame.K_RIGHT:
ship.movin_right = True
if event.key == pygame.K_LEFT:
ship.movin_left = True
if event.key == pygame.K_t:
new_bullet = Bullet(ai_settings, screen, ship, aliens,
bullets, alien)
bullets.add(new_bullet)
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = pygame.mouse.get_pos()
if but2.rect.collidepoint(x, y):
it = 0
elif but.rect.collidepoint(x, y):
it = 1
else:
if it == 1:
x, y = pygame.mouse.get_pos()
bullet = Bullet(ai_settings, screen, ship, aliens,
bullets, alien)
solds.add(bullet)
bullet.rect.x = x
bullet.rect.y = y
bullet.image = pygame.image.load('tree.gif')
#print(bullet.image)
if it == 0:
x, y = pygame.mouse.get_pos()
bullet = Bullet(ai_settings, screen, ship, aliens,
bullets, alien)
bullets.add(bullet)
bullet.rect.x = x
bullet.rect.y = y
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
if event.key == pygame.K_UP:
ship.movin_up = False
if event.key == pygame.K_2:
ship.image = pygame.image.load(random.choice(images))
if event.key == pygame.K_DOWN:
ship.movin_down = False
#276
ship.update()
aliens.update()
bullets.update(bullets, aliens)
#print('you lose')
#break
ship.blitme()
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()
collisions = pygame.sprite.groupcollide(
bullets, aliens, True, True)
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
bullets.update(bullets, aliens)
#pygame.display.flip()
ert = randint(-100, 100)
if ert == 0:
for al in solds.sprites():
ut = But(ai_settings, screen, al, aliens, bullets, alien)
bullets.add(ut)
# print(len(alienbullets)
if pygame.sprite.spritecollideany(ship, aliens):
print('you lose')
break
ship.blitme()
aliens.draw(screen)
bullets.draw(screen)
solds.draw(screen)
but2.draw_bullet()
but.draw_bullet()
alienbullets.update(bullets, aliens)
pygame.display.flip()
class FallCubic():
"""所有方块组的类"""
def __init__(self, screen, game_settings):
"""创建方块组"""
self.game_settings = game_settings
# 获取屏幕
self.screen = screen
# 创建编组
self.cubics = Group()
def add_cubics(self):
"""为空组随机加入处于任意方位的方块形状"""
# 随机选择一种形状并创建方块组实例
self.randnum_shape = randint(1, 7)
chosen_shape = self.game_settings.cubic_shape[self.randnum_shape]
shape_image_path = chosen_shape[0]
self.dir_dict = chosen_shape[1]
# 随机选择一种方向并创建为一组
randnum_dir = randint(1, 4)
self.recent_dir_num = randnum_dir
chosen_dir = self.dir_dict[randnum_dir]
self.recent_chosen_dir_dict = chosen_dir
for key, value in chosen_dir.items():
new_cubic = MetaCubic(shape_image_path)
# 把方块的初始位置放到预设位置,高度要加上预设的起始投放高度
new_cubic.rect.x = value[0]
new_cubic.rect.y = value[1] + self.game_settings.cubic_start_height
new_cubic.position_flag = key
# 加入组
self.cubics.add(new_cubic)
def drawme(self):
"""绘制方块编组"""
for cubic in self.cubics.sprites():
self.screen.blit(cubic.image, cubic.rect)
def rotate(self, temp_cubics, dead_cubics):
"""顺时针旋转方块编组"""
# 设置转出屏幕后的回移次数
move_back_right_times = 0
move_back_left_times = 0
move_back_up_times = 0
# 获取下一个方向的位置字典
next_dir_num = self.recent_dir_num + 1
if next_dir_num > 4:
next_dir_num -= 4
next_dir_dict = self.dir_dict[next_dir_num]
# 清空temp_cubics
temp_cubics.empty()
# 遍历方块位置名,修改所有元方块位置
for position_flag in next_dir_dict.keys():
# 计算位置变动值
x_diff = next_dir_dict[position_flag][
0] - self.recent_chosen_dir_dict[position_flag][0]
y_diff = next_dir_dict[position_flag][
1] - self.recent_chosen_dir_dict[position_flag][1]
# 遍历临时方块组，找到对应的元方块修改其位置
for cubic in self.cubics.sprites():
if cubic.position_flag == position_flag:
# 把fall_cubics复制到temp_cubics
new_cubic = MetaCubic('images/cubic_lblue.bmp')
new_cubic.rect.x = cubic.rect.x + x_diff
new_cubic.rect.y = cubic.rect.y + y_diff
new_cubic.position_flag = cubic.position_flag
temp_cubics.add(new_cubic)
break
for cubic in temp_cubics.sprites():
# 计算越界的长度
if cubic.rect.x >= self.game_settings.screen_width:
if (int((cubic.rect.x + self.game_settings.metacubic_width - self.game_settings.screen_width) \
/ self.game_settings.metacubic_width) > move_back_left_times):
move_back_left_times = int((cubic.rect.x + self.game_settings.metacubic_width \
- self.game_settings.screen_width) \
/ self.game_settings.metacubic_width)
elif cubic.rect.x < 0:
if (int((0 - cubic.rect.x) /
self.game_settings.metacubic_width) >
move_back_right_times):
move_back_right_times = int(
(0 - cubic.rect.x) /
self.game_settings.metacubic_width)
if cubic.rect.y >= self.game_settings.screen_height:
if (int((cubic.rect.y + self.game_settings.metacubic_width - self.game_settings.screen_height) \
/ self.game_settings.metacubic_width) > move_back_up_times):
move_back_up_times = int((cubic.rect.y + self.game_settings.metacubic_width \
- self.game_settings.screen_height) \
/ self.game_settings.metacubic_width)
# 判断是否需要旋转的标志位
rotate = True
# 出界判断是否需要旋转
# 下方出界则不允许旋转
if move_back_up_times > 0:
rotate = False
# 出界超过一个单位长度则不允许旋转
if move_back_left_times > 1 or move_back_right_times > 1:
rotate = False
# 只有前面已经允许旋转时,尝试回移
if rotate:
if move_back_right_times == 1:
temp_cubics.update(self.game_settings, pygame.K_RIGHT)
elif move_back_left_times == 1:
temp_cubics.update(self.game_settings, pygame.K_LEFT)
# 再检测碰撞
collisions = pygame.sprite.groupcollide(
temp_cubics, dead_cubics.cubics, False, False)
# 有碰撞则不做任何事情返回
if collisions:
temp_cubics.empty()
return
else:
temp_cubics.empty()
return
# 旋转及回移后的temp_cubics与dead_cubics做碰撞判断
# 记录碰撞后记元方块的不重复的x,y值
x_values = []
y_values = []
# 记录为了解决碰撞需要做的横竖移动的方向
x_move = 0
y_move = 0
collisions = pygame.sprite.groupcollide(temp_cubics,
dead_cubics.cubics, False,
False)
if collisions:
# 搜集碰撞的元方块的x,y值
for cubic in collisions:
if cubic.rect.x not in x_values:
x_values.append(cubic.rect.x)
if cubic.rect.y not in y_values:
y_values.append(cubic.rect.y)
# 如果是竖棍,则超过一个块碰撞就不允许旋转
if self.randnum_shape == 4:
if len(x_values) > 1 or len(y_values) > 1:
rotate = False
else:
# 只有一个块碰撞则确定回移方向,向下碰撞则不旋转
for cubic in temp_cubics.sprites():
if x_values[0] > cubic.rect.x:
x_move = -1
break
elif x_values[0] < cubic.rect.x:
x_move = 1
break
elif y_values[0] > cubic.rect.y:
rotate = False
break
elif y_values[0] < cubic.rect.y:
y_move = 1
break
else:
# 其他形状则判断是哪个方向的多块碰撞还是单块碰撞,再作处理
if len(x_values) > len(y_values):
# y方向碰撞,确定回移方向,向下碰撞则不旋转
for cubic in temp_cubics.sprites():
if y_values[0] > cubic.rect.y:
rotate = False
break
elif y_values[0] < cubic.rect.y:
y_move = 1
break
elif len(x_values) < len(y_values):
# x方向碰撞,确定回移方向
for cubic in temp_cubics.sprites():
if x_values[0] > cubic.rect.x:
x_move = -1
break
elif x_values[0] < cubic.rect.x:
x_move = 1
break
elif len(x_values) == len(y_values):
# 单块碰撞,同时确定两种回移方向
for cubic in temp_cubics.sprites():
if x_values[0] > cubic.rect.x:
x_move = -1
break
elif x_values[0] < cubic.rect.x:
x_move = 1
break
for cubic in temp_cubics.sprites():
if y_values[0] > cubic.rect.y:
rotate = False
break
elif y_values[0] < cubic.rect.y:
y_move = 1
break
# 只有前面已经允许旋转时,尝试回移
if not rotate:
# 不允许则退出
temp_cubics.empty()
return
else:
# 优先移动x方向
if x_move != 0:
if x_move == 1:
temp_cubics.update(self.game_settings, pygame.K_RIGHT)
elif x_move == -1:
temp_cubics.update(self.game_settings, pygame.K_LEFT)
# 再检测碰撞
collisions = pygame.sprite.groupcollide(
temp_cubics, dead_cubics.cubics, False, False)
if collisions:
# 有碰撞还要检测是否属于单方块碰撞,是的话先移回x,再y向移动,否则退出
if y_move == 0:
temp_cubics.empty()
return
elif y_move == 1:
# 先恢复
if x_move == 1:
temp_cubics.update(self.game_settings,
pygame.K_LEFT)
elif x_move == -1:
temp_cubics.update(self.game_settings,
pygame.K_RIGHT)
temp_cubics.update(self.game_settings, 'down')
# 再检测碰撞
collisions = pygame.sprite.groupcollide(
temp_cubics, dead_cubics.cubics, False, False)
if collisions:
temp_cubics.empty()
return
# 移动y方向
if y_move == 1:
temp_cubics.update(self.game_settings, 'down')
# 再检测碰撞
collisions = pygame.sprite.groupcollide(
temp_cubics, dead_cubics.cubics, False, False)
if collisions:
temp_cubics.empty()
return
# 所有移动都没碰撞则把temp_cubics的方块转移到fall_cubics,temp_cubics清空后自然返回
for cubic_t in temp_cubics.sprites():
for cubic_f in self.cubics.sprites():
if cubic_t.position_flag == cubic_f.position_flag:
# 把fall_cubics复制到temp_cubics
cubic_f.rect.x = cubic_t.rect.x
cubic_f.rect.y = cubic_t.rect.y
break
temp_cubics.empty()
# 记录最近一次的方向值和方向字典
self.recent_dir_num = next_dir_num
self.recent_chosen_dir_dict = next_dir_dict
class ScoreBoard():
"""A class to report scoring information"""
def __init__(self, setting_obj, screen, stat_obj):
"""Initialize scorekeeping attribute"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.setting_obj = setting_obj
self.stats = stat_obj
# font setting for storing information
self.text_color = (100,100,100)
self.font = pygame.font.SysFont(None, 60)
# prepare the initial score image
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_rockets()
def prep_score(self):
"""Turn the score into the render image"""
score_str = str(self.stats.score)
self.score_image = self.font.render("Score- "+score_str, True, self.text_color, self.setting_obj.trans)
# 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):
"""Turns the high score into a render image"""
high_score_str = str(self.stats.high_score)
self.high_score_image = self.font.render("High Score- "+high_score_str, True, self.text_color, self.setting_obj.trans)
# display the gigh score at middle top 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("Lvl- "+str(self.stats.level), True, self.text_color, self.setting_obj.trans)
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_rockets(self):
"""Show how many rockets are left."""
self.rockets = Group()
for rocket_number in range(self.stats.rockets_left):
rocket = Rocket(self.setting_obj, self.screen)
rocket.rect.x = 10 + rocket_number * rocket.rect.width
rocket.rect.y = 10
self.rockets.add(rocket)
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)
# draw rockets
self.rockets.draw(self.screen)
class Scoreboard():
"""显示得分的信息类"""
def __init__(self, ai_settings, screen, stats):
#初始化显示得分涉及的属性
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
#显示得分信息时使用的字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
#准备初始化得分图像和当前最高分数
self.prep_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 = 5
def prep_high_score(self):
"""将最高得分转换为渲染图像"""
high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.bg_color)
#将最高分放在屏幕最中央
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = 5
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.score_image.get_rect()
self.level_rect.right = self.screen_rect.right
self.level_rect.top = self.score_rect.bottom
def prep_ships(self):
"""显示还剩下多少艘飞船"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
"""在屏幕上显示得分和等级"""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
#绘制飞船
self.ships.draw(self.screen)
class Scoreboard():
""" A class to store and show scoring info. """
def __init__(self, infrompy_settings, screen, stats):
""" Initialize score attributes. """
self.screen = screen
self.screen_rect = screen.get_rect()
self.infrompy_settings = infrompy_settings
self.stats = stats
# font settings for score.
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.infrompy_settings.bg_color)
# Display the score in 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 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)
# Draw ships
self.ships.draw(self.screen)
def prep_high_score(self):
""" Turn the highscore 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.infrompy_settings.bg_color)
# center the highscore 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 level into a rendered image. """
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.infrompy_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 lives we have left. """
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.infrompy_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
class Scoreboard:
""" A class to report scoring information. """
def __init__(self, ai_game):
""" Initialize scorekeeping attributes. """
self.screen = ai_game.screen
self.screen_rect = ai_game.screen.get_rect()
self.settings = ai_game.settings
self.stats = ai_game.stats
self.ai_game = ai_game
# Font settings for scoring information.
self.text_color = (255, 255, 255)
self.font = pygame.font.SysFont(None, 35)
# 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 = round(self.stats.score, -1)
score_str = "Score - " + "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color)
# Display the score at the top 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 = "HiScore - " + "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_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 text into a rendered image. """
level = self.stats.level
level_str = "Level - " + str(level)
self.level_image = self.font.render(level_str, True, self.text_color)
# Position the level below the score.
self.level_rect = self.level_image.get_rect()
self.level_rect.x = self.score_rect.x
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 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.save_high_score()
self.prep_high_score()
def show_score(self):
""" Draw score, 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 save_high_score(self):
try:
# Write the file to disk
high_score_file = open("high_score.dat", "w")
high_score_file.write(str(self.stats.high_score))
high_score_file.close()
except IOError:
# Hmm, can't write it.
pass
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():
"""Klasa przeznaczona do przedstawiania informacji o punktacji"""
def __init__(self, ai_settings, screen, stats):
"""inicalizacja atrybutow dotyczacych punktacji"""
self.screen = screen
self.screen_rect = self.screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
#ustawienia czcionki
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
#przygotowanie poczatkowych obrazow z punktacja i aktualny poziom
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_level(self):
"""konwersja numeru poziomu na wygenerowany obraz"""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.bg_color)
#wyswietlanie poziomu pod aktualnym wynikiem
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
"""Wyświetla liczbę statków jakie zostały graczowi"""
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_score(self):
"""przeksztalcenie punktacji na wygenerowany obraz"""
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)
#wyswietlanie puntkacji w prawym gornym rogu ekranu
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):
"""konwersja najlepszego wyniku w grze na wygenerowany obraz"""
rounded_high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(rounded_high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.ai_settings.bg_color)
#wyswietlanie puntkacji w prawym gornym rogu ekranu
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.center = self.screen_rect.center
self.high_score_rect.top = 20
def show_score(self):
"""wyświetlenie punktacji, poziomu na ekranie"""
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)
#wyświetlanie statków
self.ships.draw(self.screen)
class Fleet:
"""A class to manage all alien and ufo sprites."""
def __init__(self, ai_settings, screen, sprite_sheet, sounds):
"""Initialize the fleet."""
self.ai_settings = ai_settings
self.screen = screen
self.sprite_sheet = sprite_sheet
self.sounds = sounds
self.aliens = Group()
self.ufos = Group()
self.alien_bullet_time = 0
self.spawn_ufo = 0
def create_fleet(self):
"""Create a full fleet of aliens."""
row = 4
self.aliens.empty()
# Create the fleet of aliens.
for row_number in range(self.ai_settings.number_rows):
for alien_number in range(self.ai_settings.number_aliens_x):
self.create_alien(alien_number, row_number, row)
row -= 1
def create_alien(self, alien_number, row_number, row):
"""Create an alien and place it in the row."""
alien = Alien(ai_settings=self.ai_settings,
screen=self.screen,
sprite_sheet=self.sprite_sheet,
row=row)
# alien_width = alien.rect.width
alien_width = 50
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = 100 + alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def check_aliens_bottom(self):
"""Check if any aliens have reached the bottom of the screen."""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
return True
def check_fleet_edges(self):
"""Respond appropriately if any aliens have reached an edge."""
for alien in self.aliens.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
def change_fleet_direction(self):
"""Drop the entire fleet and change the fleet's direction."""
for alien in self.aliens.sprites():
alien.rect.y += self.ai_settings.fleet_drop_speed
self.ai_settings.fleet_direction *= -1
def update_aliens(self, ship, display, bullets):
"""Check if the fleet is at an edge, and then update the positions of all aliens in the fleet."""
self.check_fleet_edges()
if display.animate_aliens == self.ai_settings.animate_aliens:
for alien in self.aliens:
alien.switch_image()
display.animate_aliens = 0
display.animate_aliens += 1
self.aliens.update()
# Look for alien-ship collisions.
if pygame.sprite.spritecollideany(ship, self.aliens):
ship.ship_hit(bullets=bullets, fleet=self, display=display)
# Shoot bullets from aliens
if self.alien_bullet_time >= random.randint(500, 1000):
alien_list = self.aliens.sprites()
alien_firing = len(alien_list) - 11
if alien_firing < 0:
alien_firing = 0
if len(alien_list) > 0:
bullets.alien_shoot(alien_list[random.randint(
alien_firing,
len(alien_list) - 1)])
self.alien_bullet_time = 0
self.alien_bullet_time += 1
# Look for aliens hitting the bottom of the screen.
if self.check_aliens_bottom():
ship.ship_hit(bullets=bullets, fleet=self, display=display)
def create_ufos(self):
"""Create ufos at a random interval."""
if len(self.ufos) < 1:
self.sounds.ufo_sound.play(-1)
ufo = Ufo(ai_settings=self.ai_settings,
screen=self.screen,
sprite_sheet=self.sprite_sheet)
ufo.rect.x = 50
ufo.rect.y = 60
self.ufos.add(ufo)
def update_ufos(self):
"""Check if ufo is at the edge, de-spawn ufo if it is."""
self.check_ufo_edges()
self.ufos.update()
def check_ufo_edges(self):
"""Check if ufo reached the edge of the screen."""
for ufo in self.ufos.sprites():
if ufo.check_edges():
self.sounds.ufo_sound.stop()
self.spawn_ufo = 0
def run_game():
pygame.init()
screen_size = (600, 385)
screen = pygame.display.set_mode(screen_size)
mario_main_menu_pic_load = pygame.image.load(
'./mario_pics/super_mario_logo.png')
mario_main_menu_pic = pygame.transform.scale(mario_main_menu_pic_load,
[500, 200])
main_menu_x = 50
main_menu_y = 50
mario = Mario(screen)
background = Background(screen, './mario_pics/full_background_no_sky.png',
mario, 0)
main_menu_background = Background(
screen, './mario_pics/full_background_no_sky.png', mario, 300)
question_blocks = Group()
reg_blocks = Group()
physics = Physics()
# first_goomba = Goomba(screen)
enemies = Group()
dead_enemies = Group()
stars = Group()
game_on = True
tick = 0
power_timer = 0
background_color = (93, 148, 251)
main_menu_font = pygame.font.Font('./mario_pics/8_bit_pusab.ttf', 10)
star_game_text = main_menu_font.render('Press SPACE to Start.', False,
(0, 0, 0))
start_text_x = 200
start_text_y = 250
game_over_font = pygame.font.Font('./mario_pics/8_bit_pusab.ttf', 25)
main_menu = True
start_game = False
for i in background.block_locations:
question_blocks.add(QuestionBlock(screen, mario.speed, i))
# for i in background.reg_block_locations:
# reg_blocks.add(RegBlock(screen, mario.speed, i))
# for block in question_blocks:
# stars.add(Star(screen, block.x))
r = randint(150, 255)
g = randint(150, 255)
b = randint(150, 255)
#//////////////////////////////
#////////MUSICnSOUNDS/////////
#////////////////////////////
theme_song_load = pygame.mixer.music.load('./sounds/mario_theme.wav')
theme_song = pygame.mixer.music.play(-1)
# star_power_song_load = pygame.mixer.music.load('./sounds/mario_dubstep.wav')
star_power_song = pygame.mixer.Sound('./sounds/mario_dubstep.wav')
star_power_song.set_volume(.2)
power_up_sound = pygame.mixer.Sound('./sounds/smb_powerup.wav')
death_sound = pygame.mixer.Sound('./sounds/smb_mariodie.wav')
while game_on:
# print main_menu
if main_menu:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == 32:
start_game = True
if start_game:
if main_menu_background.y > 0:
main_menu_background.y -= 1
main_menu_y -= 1
start_text_y -= 1
elif main_menu_background.y == 0:
main_menu = False
screen.fill(background_color)
screen.blit(mario_main_menu_pic, (main_menu_x, main_menu_y))
screen.blit(star_game_text, [start_text_x, start_text_y])
main_menu_background.draw_background(mario)
# pygame.display.flip()
# print tick
elif not main_menu:
for i in background.goomba_spawn_points:
if background.x == i:
enemies.add(Goomba(screen))
if background.x < i:
background.goomba_spawn_points.remove(i)
check_events(background, mario, screen)
screen.fill(background_color)
background.draw_background(mario)
for star in stars:
star.draw_me(background, physics, question_blocks, mario)
for block in question_blocks:
block.draw_block(background)
for blokc in reg_blocks:
block.draw_block(background)
for block in question_blocks:
if block.x <= mario.x + 27 and block.x >= mario.x:
if mario.hit_block and block.power_up_remaining > 0:
stars.add(Star(screen, block.x))
mario.hit_block = False
block.power_up_remaining -= 1
elif block.power_up_remaining <= 0:
mario.hit_block = False
mario.draw_mario(physics, background, question_blocks, stars)
# question_block.draw_block(background)
# print enemies
# print question_block.y
for enemy in enemies:
enemy.draw_goomba(mario, physics, background)
mario.check_mario_is_alive(background, enemy, death_sound)
for enemy in dead_enemies:
enemy.dead = True
enemy.draw_goomba(mario, physics, background)
if mario.star_power:
theme_song = pygame.mixer.music.pause()
star_power_song.play()
power_timer += 1
mario.max_jump_height = 100
if power_timer == 10:
mario.scale += 15
background.floor -= 14
elif power_timer == 20:
mario.scale += 15
background.floor -= 14
elif power_timer == 30:
mario.scale += 15
background.floor -= 14
# star_power_song = pygame.mixer.music.play(-1)
background_color = (r, g, b)
if tick % 5 == 0:
r += 10
g += 15
b += 16
if r > 230:
r -= 150
if g > 230:
g -= 150
if b > 230:
b -= 150
for enemy in enemies:
distance_from_enemy = fabs(mario.x -
enemy.x) + fabs(mario.y -
enemy.y)
if distance_from_enemy < 100:
enemy.dead == True
dead_enemies.add(enemy)
# screen.blit(goomba_smush_load, [200, 150])
enemies.remove(enemy)
# for enemy in dead_enemies:
# screen.blit(goomba_smush_load, [enemy.x,enemy.y])
if power_timer > 600:
mario.star_power = False
power_timer = 0
background.floor = 290
mario.max_jump_height = 163
background_color = (93, 148, 251)
star_power_song.stop()
theme_song = pygame.mixer.music.unpause()
if mario.alive == False:
game_over_text = game_over_font.render("GAME OVER!", False,
(0, 0, 0))
screen.blit(game_over_text, [150, 150])
theme_song = pygame.mixer.music.stop()
# print background.x
# first_goomba.draw_goomba(mario)
pygame.display.flip()
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)
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()
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_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:
# 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
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
new_bullet = Bullet(ai_settings, screen, ship, mouse_x,
mouse_y)
bullets.add(new_bullet)
ship.update()
bullets.update()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
screen.fill(ai_settings.bg_color)
for bullet in bullets.sprites():
bullet.draw_bullet()
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
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()
aliens.draw(screen)
alien.blitme()
chek_fleet_edges(ai_settings, aliens)
aliens.update()
if pygame.sprite.spritecollideany(ship, aliens):
print('you lose')
break
pygame.display.flip()
class Scoreboard():
""" """
def __init__(self, ai_settings, screen, stats):
""" """
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
self.text_color = (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 Scoreboard:
def __init__(self, ai_game):
#initialize scorekeeping attribute
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 info
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 32)
#prepate the initial scrore image
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_ships(self):
#show how many ships are left
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ship(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_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):
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.bg_color)
#center the high score at the top of the screen
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def prep_level(self):
#turn 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 the score
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10
def show_score(self):
#draw score to the screen
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
def check_high_score(self):
#check to see if there is a new high scrore
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
class Scoreboard():
""" A class to report scoring info"""
def __init__(self, ai_settings, screen, stats):
"""init the scorekeeping"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Font setting for the scoreboard
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prep the different score images
self.prep_high_score()
self.prep_score()
self.prep_ships()
self.prep_level()
self.prep_ships()
def prep_level(self):
"""Turn the level into rendered image"""
self.level_image = self.font.render(str(self.stats.level), True, self.text_color, self.ai_settings.bg_color)
# Place the level just 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 prep_score(self):
""" Turn the score into a rendered image"""
round_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(round_score)
self.score_image = self.font.render(score_str, True, self.text_color, self.ai_settings.bg_color)
# Display the score at the top 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 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 on top left
self.ships.draw(self.screen)
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)
# Place the high score on top
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.screen_rect.top
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 = (20, 20, 20)
self.font = pygame.font.SysFont(None, 48)
self.prep_score()
self.prep_level()
self.prep_ships()
self.prep_high_score()
def prep_score(self):
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.settings.bgcolor)
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20
def prep_level(self):
level_str = str(self.stats.level)
self.level_image = self.font.render(level_str, True, self.text_color,
self.settings.bgcolor)
self.level_image_rect = self.level_image.get_rect()
self.level_image_rect.right = self.screen_rect.right
self.level_image_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
self.ships = Group()
for ship_number in range(self.stats.ships_left):
ship = Ships(self.ai_game)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def prep_high_score(self):
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color,
self.settings.bgcolor)
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 check_high_score(self):
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.prep_high_score()
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_image_rect)
self.ships.draw(self.screen)
class Scoreboard():
"""显示得分等信息"""
def __init__(self, ai_settings, screen, stats):
"""初始化得分涉及的属性"""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# 字体设置
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# 初始得分图像
self.prep_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.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)
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 Scoreboard():
def __init__(self, game_settings, screen, stats):
""""Initialize scorekeeping attributes"""
self.game_settings = game_settings
self.screen = screen
self.stats = stats
self.screen_rect = screen.get_rect()
# 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()
# Prepare the highest score image
self.prep_high_score()
# Prepare the level
self.prep_level()
# Prepare ship (lives) left
self.prep_ships()
def prep_score(self):
""""Turn the scores 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.game_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 highest scores into a rendered image"""
rounded_high_score = int(round(self.stats.high_score, -1))
high_score_str = "{:,}".format(rounded_high_score)
self.high_score_image = self.font.render(high_score_str, True,
self.text_color, self.game_settings.bg_color)
# Display the high score at the top middle of the screen
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.right = self.screen_rect.centerx
self.high_score_rect.top = 20
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.game_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):
"""Show how many ships are left"""
self.ships = Group()
for ship_number in range(self.stats.ship_left):
ship = Ship(self.screen, self.game_settings)
ship.rect.x = 10 + ship_number * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
def show_score(self):
""""Draw score to the screen"""
self.screen.blit(self.score_image, self.score_rect)
def show_high_score(self):
"""Draw the highest score to the screen"""
self.screen.blit(self.high_score_image, self.high_score_rect)
def show_level(self):
"""Draw the highest score to the screen"""
self.screen.blit(self.level_image, self.level_rect)
def show_ships(self):
""""Draw the ships left (lives) to the screen"""
self.ships.draw(self.screen)
class Scoreboard:
"""A class to report scoring information."""
def __init__(self, ss):
"""Initialize scorekeeping attributes."""
self.ai_game = ss
self.screen = ss.screen
self.screen_rect = self.screen.get_rect()
self.settings = ss.settings
self.stats = ss.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("High score picked up")
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):
sb_ship = ScoreboardShip(self.ai_game)
sb_ship.rect.x = 10 + ship_number * sb_ship.rect.width
sb_ship.rect.y = 10
self.ships.add(sb_ship)
if shownoise and not present:
continue
sprite = Sprite()
sprite.image = Surface((4,4), flags=SRCALPHA)
if present:
sprite.exists = True
male = sex(x/8,y/8)
draw.circle(sprite.image, (196,196,255) if male else (255,196,196),
(2,2), 2, 1 if shownoise else 0)
else:
sprite.exists = False
if not shownoise:
draw.circle(sprite.image, (128,128,128), (2,2), 2, 1)
sprite.rect = sprite.image.get_rect().move(x, y)
sprites.add(sprite)
limit = Clock()
done = False
def family(generation, index):
fam = 0
infam = False
for i in range(0, index):
if personat(generation, i):
if not infam:
infam = True
else:
if infam:
infam = False
class Scoreboard():
"""Uma classe para mostrar informações sobre pontuação."""
def __init__(self, ai_settings, screen, stats):
"""Inicializa os atributos da pontuação."""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Configurações de fonte para as informações de pontuação
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 48)
# Prepara a imagem da pontuação inicial
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_score(self):
"""Transforma a pontuação em uma imagem renderizada."""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
# Exibe a pontuação na parte superior direita da tela
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):
"""Desenha a pontuação na tela."""
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)
# Desenha as espaçonaves
self.ships.draw(self.screen)
def prep_high_score(self):
"""Transforma a pontuação máxima em uma imagem renderizada."""
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)
# Centraliza a pontuação máxima na parte superior da tela
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def prep_level(self):
"""Transforma o nível em uma imagem renderizada."""
self.level_image = self.font.render(str(self.stats.level), True,
self.text_color,
self.ai_settings.bg_color)
# Posiciona o nível abaixo da pontuação
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):
"""Mostra quantas espaçonaves restam."""
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 update_high_score(self):
# Atualiza e grava a pontuação máxima
with open('high_score.json', 'w') as f_obj:
json.dump(self.stats.high_score, f_obj)
