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)
def run_game():
global ch, dobollet, t, bulets
forrand = 1000
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)
blocks = Group()
cu = 1
cd = 1
cr = 1
moneys = 0
cl = 1
tank = 0
fuster = 1
poweraps = Group()
updatenow = 0
alienbullets = Group()
score = 0
do_liberint(pygame, ship, Block, aliens, blocks,
Alien_what_go_left_and_right, ai_settings, screen, screen,
0, Alien_what_go_up_and_down, poweraps, 0, 0, 0, 0, 0)
for power in poweraps.sprites():
power.image = pygame.image.load('bomb.gif')
buttons = Group()
bg_color = (20, 250, 200)
upbut = Button(ai_settings, screen)
buttons.add(upbut)
downbut = Button(ai_settings, screen)
buttons.add(downbut)
leftbut = Button(ai_settings, screen)
buttons.add(leftbut)
rightbut = Button(ai_settings, screen)
buttons.add(rightbut)
aliens.empty()
while True:
# if cr == 0:
# for alien in aliens.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# elif cl == 0:
# #updatenow = 1
# for alien in aliens.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
if cr == 0:
ship.x += fuster
ship.rect.x = ship.x
if pygame.sprite.spritecollideany(ship, blocks):
ship.x -= fuster
ship.rect.x = ship.x
elif cl == 0:
ship.x -= fuster
ship.rect.x = ship.x
if pygame.sprite.spritecollideany(ship, blocks):
ship.x += fuster
ship.rect.x = ship.x
if cd == 0:
ship.y += fuster
ship.rect.y = ship.y
if pygame.sprite.spritecollideany(ship, blocks):
ship.y -= fuster
ship.rect.y = ship.y
if cu == 0:
ship.y -= fuster
ship.rect.y = ship.y
if pygame.sprite.spritecollideany(ship, blocks):
ship.y += fuster
ship.rect.y = ship.y
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1:
first = randint(0, 220)
second = randint(0, 220)
three = randint(0, 220)
ai_settings.bg_color = (first, second, three)
if event.key == pygame.K_b:
sys.exit()
if event.key == pygame.K_RIGHT:
#ship.movin_right = True
cr = 0
cl = 1
cd = 1
c = 1
t = 2
if event.key == pygame.K_LEFT:
#ship.movin_left = True
cl = 0
t = 3
if event.key == pygame.K_r:
#ship.movin_left = True
if len(bullets) <= bulets:
new_bullet = Bullet(ai_settings, screen, ship,
aliens, bullets, 0)
bullets.add(new_bullet)
if event.key == pygame.K_UP:
cu = 0
t = 0
if event.key == pygame.K_DOWN:
cd = 0
t = 1
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
ship.movin_right = False
cr = 1
if event.key == pygame.K_LEFT:
ship.movin_left = False
cl = 1
if event.key == pygame.K_UP:
cu = 1
if event.key == pygame.K_DOWN:
cd = 1
if event.key == pygame.K_2:
ship.image = pygame.image.load(random.choice(images))
if event.key == pygame.K_DOWN:
ship.movin_down = False
#276
#276
ship.update(blocks, ship)
bullets.update(bullets, aliens)
collisions = pygame.sprite.groupcollide(bullets, aliens, True,
True)
#print('you lose')
#break
ship.blitme()
# pygame.display.flip()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0 or bullet.rect.bottom >= 900 or bullet.rect.centerx <= 0 or bullet.rect.centerx >= 1000:
bullets.remove(bullet)
screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.copy():
# if bullet.rect.bottom >= 900:
# bullets.remove(bul
# screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.sprites():
# bullet.draw_bullet()
# first = randint(0,200)
# second = randint(0,200)
# three = randint(0,200)
# ai_settings.bullet_color = (first,second,three)
# collisins = pygame.sprite.groupcollide(blocks,bullets,True,True)
if pygame.sprite.spritecollideany(ship, aliens):
print('you lose')
sys.exit()
for alien in poweraps.sprites():
if pygame.sprite.spritecollideany(ship, poweraps):
poweraps.remove(alien)
bulets += 1
for bullet in bullets.sprites():
bullet.draw_bullet()
if collisions:
moneys += 1
collisions = pygame.sprite.groupcollide(
bullets, blocks, True, False)
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
bullets.update(bullets, aliens)
ship.blitme()
#chekupdown_fleet_edges(ai_settings,aliens)
#alien.blitme()
bullets.draw(screen)
alienbullets.update(bullets, aliens)
if updatenow == 0:
aliens.update()
print(len(aliens))
blocks.draw(screen)
blocks.update()
if len(aliens) <= 0:
print('you win')
break
poweraps.draw(screen)
buttons.draw(screen)
pygame.display.flip()
def run_game():
global ch, dobollet, db, wea, t
pygame.init()
turn = 0
ch = 10
fg = 1
pfg = 1
joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
print(len(joysticks))
for joystick in joysticks:
joystick.init()
i = 0
j = False
sit = False
sco = 0
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alien Invasion')
ship = Ship(ai_settings, screen)
bullets = Group()
ships = Group()
blocks = Group()
aliens = Group()
l = 0
r = 0
godown = 0
sb = Scoreboard(ai_settings, screen, 0, sco)
alies = Group()
alien = Alien(ai_settings, screen, ship, 0, 1)
buttons = Group()
eateat = Alien(ai_settings, screen, ship, ship, ship)
aliens.add(eateat)
yu = False
#rint(ship.y)iii
alienbullets = Group()
ert = 0
tr = [
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 0, 0, 0, 0, 1, 1, 1, 1, 0,
0, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 2
]
sty = Group()
uii = 0
poweraps = Group()
do_liberint(ship, Block, aliens, blocks, Alien_what_go_up_and_down,
ai_settings, screen, tr, Alien_what_go_up_and_down,
poweraps, poweraps)
aiens = Group()
ant = Ant_men(ai_settings, screen, ship)
ships.add(ship)
time = 0
un = 0
while True:
sb.show_score()
rand = randint(-1000, 1000)
if j == True and i == 0:
ert = 0
# ship.y -= 1*pfg
for alien in blocks.sprites():
alien.y += pfg
alien.rect.y = alien.y
#for alien in poweraps.sprites():
ant.y += pfg
ant.rect.y = ant.y
fg += 1 * pfg
#print(ship.y)
# ship.rect.y = ship.y
if fg == 190:
pfg *= -1
if fg == 0:
i = 0
pfg *= -1
j = False
scr = screen.get_rect()
if j == False and godown == 0:
for alien in blocks.sprites():
alien.y -= 1
alien.rect.y = alien.y
ant.y -= 1 # #updatenow = 1
# for alien in aliens.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
if r == 0:
for alien in blocks.sprites():
alien.x -= 1
alien.rect.x = alien.x
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if l == 0:
for alien in blocks.sprites():
alien.x += 1
alien.rect.x = alien.x
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if r == 0:
ant.x -= 1
ant.rect.x = ant.x
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if l == 0:
ant.x += 1
ant.rect.x = ant.x # if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
for event in pygame.event.get():
#for event in pygame.event.get():
# # if event.type == pygame.KEYDOWN:
# if event.key == pygame.K_1:
# first = randint(0,220)
# second = randint(0,220)
# three = randint(0,220)
# ai_settings.bg_color = (first,second,three)
# if event.key == pygame.K_b:
# sys.exit()
# if event.key == pygame.K_RIGHT:
# #ship.movin_right = True
# cr = 0
# t = 2
# if event.key == pygame.K_LEFT:
# #ship.movin_left = True
# cl = 0
# t = 3
# if event.key == pygame.K_r:
# #ship.movin_left = True
# if len(bullets) <= bulets:
# new_bullet = Bullet(ai_settings,screen,ship,aliens,bullets,0)
# bullets.add(new_bullet)
# if event.key == pygame.K_UP:
# cu = 0
# t = 0
if event.type == pygame.JOYAXISMOTION:
buttons = joystick.get_numaxes()
for i in range(buttons):
but = joystick.get_axis(0)
if but < -.5:
ship.x -= 1
ship.rect.x = ship.x
if pygame.sprite.spritecollideany(ship, blocks):
ship.x += fuster
ship.rect.x = ship.x
t = 3
but = joystick.get_axis(0)
if but > .5:
ship.x += 1
ship.rect.x = ship.x
if pygame.sprite.spritecollideany(ship, blocks):
ship.x -= fuster
ship.rect.x = ship.x
t = 2
but = joystick.get_axis(1)
if but < -.5:
j = True
# but = joystick.get_axis(1)
# if but < -.5:
# ship.y -= 1
# ship.rect.y = ship.y
# if pygame.sprite.spritecollideany(ship,blocks):
# ship.y += fuster
# ship.rect.y = ship.y
# t = 0
# but = joystick.get_axis(1)
# if but > .5:
# ship.y += 1
# ship.rect.y = ship.y
# if pygame.sprite.spritecollideany(ship,blocks):
# ship.y -= fuster
# ship.rect.y = ship.y
# t = 1
if event.type == pygame.JOYHATMOTION:
buttons = joystick.get_numhats()
for i in range(buttons):
but = joystick.get_hat(i)
if but == (-1, 0):
l = 0
r = 1
cu = 1
cd = 1
t = 3
but = joystick.get_hat(i)
if but == (1, 0):
l = 1
r = 0
cu = 1
cd = 1
t = 2
but = joystick.get_hat(i)
if but == (0, 1):
j = True
but = joystick.get_hat(i)
if event.type == pygame.JOYBUTTONDOWN:
button = joystick.get_button(True)
# print(button)
#pass
if button == 1:
new_bullet = Bullet(ai_settings, screen, ship, aliens,
bullets, alien, t)
bullets.add(new_bullet)
button = joystick.get_button(True)
if button == 0:
if un == 0:
upda = 1
if un == 1:
upda = 0
un = upda
elif event.type == pygame.JOYBUTTONUP:
#buttons = joystick.get_numbuttons()
button = joystick.get_button(False)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
cl2 = 0
cr2 = 1
cu2 = 1
cd2 = 1
t2 = 3
if event.key == pygame.K_RIGHT:
cl2 = 1
cr2 = 0
cu2 = 1
cd2 = 1
t2 = 2
#but = joystick.get_hat(i)
if event.key == pygame.K_DOWN:
cl2 = 1
cr2 = 1
cu2 = 1
cd2 = 0
t2 = 1
#but = joystick.get_hat(i)
if event.key == pygame.K_UP:
cl2 = 1
cr2 = 1
cu2 = 0
cd2 = 1
t2 = 0
if event.key == pygame.K_v:
new_bullet = Bullet(ai_settings, screen, ship2, aliens,
bullets, alien, t2)
bullets.add(new_bullet)
# elif event.type == pygame.KEYUP:
# if event.key == pygame.K_RIGHT:
# ship.movin_right = False
# cr = 1
# if event.key == pygame.K_LEFT:
# ship.movin_left = False
# cl = 1
# if event.key == pygame.K_UP:
# cu = 1
# if event.key == pygame.K_DOWN:
# cd = 1
# if event.key == pygame.K_2:
# ship.image = pygame.image.load(random.choice(images))
# if event.key == pygame.K_DOWN:
# ship.movin_down = False
# #276
#276
ship.update(blocks, ship)
bullets.update(bullets, aliens)
collisions = pygame.sprite.groupcollide(bullets, aliens, True,
True)
#print('you lose')
#break
ship.blitme()
if pygame.sprite.spritecollideany(ship, blocks):
for alien in blocks.sprites():
alien.y += 1
alien.rect.y = alien.y
ant.y += 1
ant.rect.y = ant.y
# godown = 0
# pygame.display.flip()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0 or bullet.rect.bottom >= 900 or bullet.rect.centerx <= 0 or bullet.rect.centerx >= 1000:
bullets.remove(bullet)
screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.copy():
# if bullet.rect.bottom >= 900:
# bullets.remove(bul
# screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.sprites():
# bullet.draw_bullet()
# first = randint(0,200)
# second = randint(0,200)
# three = randint(0,200)
# ai_settings.bullet_color = (first,second,three)
# collisins = pygame.sprite.groupcollide(blocks,bullets,True,True)
collisions = pygame.sprite.groupcollide(ships, poweraps, False,
True)
# for alien in aliens.sprites():
# if pygame.sprite.spritecollideany(alien,blocks):
# alien.duraction *= -1
for bullet in bullets.sprites():
bullet.draw_bullet()
collisions = pygame.sprite.groupcollide(
bullets, aliens, True, True)
if collisions:
moneys += 1
collisions = pygame.sprite.groupcollide(
bullets, blocks, True, False)
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
bullets.update(bullets, aliens)
ship.blitme()
#chekupdown_fleet_edges(ai_settings,aliens)
#alien.blitme()
bullets.draw(screen)
sb.show_score()
alienbullets.update(bullets, aliens)
aliens.draw(screen)
if un == 0:
blocks.draw(screen)
blocks.update()
if pygame.sprite.spritecollideany(ant, ships):
print('you lose')
sys.exit()
if pygame.sprite.spritecollideany(ant, bullets):
ch -= 1
bullets.empty()
if ch <= 0:
print('you win')
break
print(len(poweraps))
#if bezero == 34:
#bezero = 0
sb.show_score()
#poweraps.draw(screen)
ant.blitme()
ant.update()
pygame.display.flip()
class Room:
""" base class for all rooms """
# these variables are set in the subclass
width = None
height = None
def __init__(self, screen):
""" Initialization of our lists """
self.wall_list = Group()
self.coin_list = Group()
self.plat_move = Group()
self.door_list = OrderedUpdates()
# the screen and its rect
self.screen = screen
self.screct = self.screen.get_rect()
# the room's size and image
self.rect = Rect(0, 0, self.width, self.height)
self.bckimg = gf.get_checkboard(20, 20, self.width, self.height,
[WHITE, GREY])
#self.bckimg.fill(WHITE)
def draw(self):
""" Draw the room on the screen"""
self.screen.blit(self.bckimg, self.rect)
self.wall_list.draw(self.screen)
self.door_list.draw(self.screen)
self.coin_list.draw(self.screen)
def move_room(self, move_x, move_y):
""" Move all walls in the room """
self.move_obj(move_x, move_y)
self.rect.x += move_x
self.rect.y += move_y
def move_obj(self, move_x, move_y):
""" Move all objects in the room, but not the room itself """
self.wall_list.update(move_x, move_y)
self.door_list.update(move_x, move_y)
self.coin_list.update(move_x, move_y)
def reset(self, player=None):
""" reset the room rect's topleft to the topleft of the screen and
move everything accordingly. """
displace_x = self.screct.x - self.rect.x
displace_y = self.screct.y - self.rect.y
self.move_room(displace_x, displace_y)
if player:
player.rect.x += displace_x
player.rect.y += displace_y
def old_set_around(self, player):
""" Move the room so that the room and the player are in the right place"""
plax = player.rect.x
play = player.rect.y
roox = self.rect.x
rooy = self.rect.y
# check horizontal position
if player.rect.centerx < self.rect.left + self.screct.centerx:
self.rect.left = self.screct.left
dis_x = self.rect.x - roox
self.move_obj(dis_x, 0)
player.rect.x += dis_x
elif player.rect.centerx > self.rect.right - self.screct.centerx:
self.rect.right = self.screct.right
dis_x = self.rect.x - roox
self.move_obj(dis_x, 0)
player.rect.x += dis_x
else:
player.rect.centerx = self.screct.centerx
dis_x = player.rect.x - plax
self.move_room(dis_x, 0)
# check vertical position
if player.rect.centery < self.rect.top + self.screct.centery:
self.rect.top = self.screct.top
dis_y = self.rect.y - rooy
self.move_obj(0, dis_y)
player.rect.y += dis_y
elif player.rect.centery > self.rect.bottom - self.screct.centery:
self.rect.bottom = self.screct.bottom
dis_y = self.rect.y - rooy
self.move_obj(0, dis_y)
player.rect.y += dis_y
else:
player.rect.centery = self.screct.centery
dis_y = player.rect.y - play
self.move_room(0, dis_y)
def reset_coins(self):
""" reset all coins """
# improve this so it doesn't have to keep removing sprites already in the group
self.coin_list.empty()
self.get_coins()
def get_coins(self):
""" get the coins for the room, overloaded in subclasses """
pass
class Game():
def __init__(self):
#setup
pygame.init()
pygame.font.init()
self.font = pygame.font.Font(None,24)
self.fontColor = (0,0,0)
pygame.mixer.init()
pygame.display.set_mode(SCREEN)
pygame.display.set_caption('#ElJuegoDeLasJoincic')
self.screen = pygame.display.get_surface()
self._quit=False
self.clock = pygame.time.Clock()
self.controller= Controller()
self.background = load_image("background.png")
self.menu_background = load_image("menu_background.png")
self.menu_iniciar = load_image("menu_iniciar.png")
self.menu_salir = load_image("menu_salir.png")
self.gameover = load_image("gameover.png")
self.cursor = load_image("cursor.png")
self.arrow = load_image("arrow.png")
self.player = Player()
self.group = Group()
self.protocolo = Protocolo()
self.group.add(self.player)
self.groupOyentes = Group()
self.groupTakitos = Group()
self.groupHUD = Group()
self.state= GAME_INIT
def pause(self):
pass
def wait(self):
pass
def hayPuesto(self):
for row in self.oyentes:
for val in row:
if val == 0:
return True
return False
def init(self):
self.screen.blit(self.menu_background,(0,0))
rect = self.screen.blit(self.menu_iniciar,(200,200))
if rect.collidepoint(self.controller.mouse.position):
self.screen.blit(self.menu_iniciar,(200,200))
if self.controller.mouse.click:
self.state = GAME_LOOP
self.oyentes=[
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
]
self.level=1
self.initLevel();
rect = self.screen.blit(self.menu_salir,(200,260))
if rect.collidepoint(self.controller.mouse.position):
self.screen.blit(self.menu_salir,(200,260))
if self.controller.mouse.click:
sys.exit(0)
def initLevel(self):
count= (self.level - 1 )*2 + 4
self.oyentes=[
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
[0,0,0,0,0],
]
self.groupOyentes.empty()
self.groupTakitos.empty()
for i in range(count):
if self.hayPuesto():
oyente=Oyente()
self.groupOyentes.add(oyente)
oyente.onScoreTick = self.comprobarScore
while True:
i = randrange(5)
j = randrange(5)
if self.oyentes[i][j]== 0:
oyente.rect.x=160+(i*oyente.rect.w)
oyente.rect.y=j*oyente.rect.h
break
self.time_next_level=time.time()+ 60
self.puntos=0
def comprobarScore(self, oyente):
if oyente.state == OYENTE_DESPIERTO or \
oyente.state == OYENTE_DISTRAIDO or \
oyente.state == OYENTE_ABURRIDO:
self.groupHUD.add(TextHUD(oyente.rect, "+1"))
if oyente.state == OYENTE_DORMIDO:
self.groupHUD.add(TextHUD(oyente.rect, "-1"))
def loop(self):
#input
self.player.update(self)
self.protocolo.update(self)
for oyente in self.groupOyentes:
oyente.update(self)
for takito in self.groupTakitos:
takito.update(self)
self.groupHUD.update()
#render
self.screen.blit(self.background,(0,0))
self.screen.blit(self.protocolo.image, self.protocolo.rect)
self.groupOyentes.draw(self.screen)
self.groupTakitos.draw(self.screen)
self.group.draw(self.screen)
self.groupHUD.draw(self.screen)
if self.player.state == PLAYER_AIM:
image= pygame.transform.scale(self.arrow, ( self.arrow.get_width()+ int( MAX_DISTAN_FORCE*self.player.force) ,self.arrow.get_height() ))
image= pygame.transform.rotate(image, self.player.arrow_angle)
rect=image.get_rect()
rect.centerx=self.player.rect.centerx
rect.centery=self.player.rect.centery
self.screen.blit(image, rect)
delta_time=self.time_next_level - time.time()
self.screen.blit( self.font.render("Faltan: %d : %d " % ( (delta_time/60) , delta_time % 60),True, self.fontColor ) , (15,15) )
self.screen.blit( self.font.render(" Nivel: %d " % self.level ,True, self.fontColor ) , (565,15) )
self.screen.blit( self.font.render(" Puntos: %d " % self.puntos ,True, self.fontColor ) , (365,15) )
if delta_time <= 0:
count= len(self.groupOyentes)
count_len=0
for sprite in self.groupOyentes:
if sprite.state <= OYENTE_NORMAL:
count_len+=1
if count_len >= count /2:
self.level+=1
self.initLevel()
else:
self.state= GAME_END
def end(self):
self.screen.blit(self.gameover, (0,0))
def update(self):
self.controller.update()
self.screen = pygame.display.get_surface()
if self.state <= GAME_PAUSE:
self.pause()
elif self.state <= GAME_INIT:
self.init()
elif self.state <= GAME_WAIT:
self.wait()
elif self.state <= GAME_LOOP:
self.loop()
elif self.state <= GAME_END:
self.end()
if self.player.state != PLAYER_AIM:
self.screen.blit(self.cursor, self.controller.m.position)
def go(self):
while not self._quit:
self.update()
pygame.display.flip()
self.clock.tick(TICKPERSEC)
class AlienInvasion(object):
"""游戏管理的类"""
def __init__(self, ):
"""
初始化游戏, 创建游戏资源
"""
# 初始化pygame, 设置和屏幕对象
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 统计信息及记分牌
self.stats = GameStats(self)
self.sb = ScoreBoard(self)
# 飞船
self.ship = Ship(self)
# 子弹编组
self.bullets = Group()
# 外星人群
self.aliens = Group()
self.create_fleet()
# Play按钮
self.play_button = Button(self, "Play")
def run_game(self, ):
"""
运行游戏
"""
while True:
# 监视键盘和鼠标事件
self.check_events()
if self.stats.game_active:
# 游戏处于激活状态时, 才更新
self.ship.update()
self.update_bullets()
self.updata_aliens()
# 更新屏幕
self.update_screen()
def check_events(self, ):
"""
响应键盘和鼠标事件
"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self.check_keydown_events(event)
elif event.type == pygame.KEYUP:
self.check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self.check_play_button(mouse_pos)
def check_keydown_events(self, event):
"""
响应按键
"""
if event.key == pygame.K_RIGHT:
# 按下向右方向键时, 右移标志为True
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
# 按下向左方向键时, 左移标志为True
self.ship.moving_left = True
elif event.key == pygame.K_SPACE:
# 按下空格键时, 创建一颗子弹并将其放入bullets中
self.fire_bullet()
elif event.key == pygame.K_q:
# 按下q键时, 退出游戏
sys.exit()
def check_keyup_events(self, event):
"""
响应松开
"""
if event.key == pygame.K_RIGHT:
# 松开向右方向键时, 右移标志为False
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
# 松开向左方向键时, 左移标志为False
self.ship.moving_left = False
def check_play_button(self, mouse_pos):
"""
响应Play按钮, 单击Play按钮时激活游戏, 重新开始游戏
"""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active: # 仅在非激活状态点击按钮才有效
# 重置游戏设置
self.settings.initialize_dynamic_settings()
# 隐藏光标, 游戏激活后, 不显示光标, 避免影响游戏体验
pygame.mouse.set_visible(False)
self.stats.reset_stats() # 重置游戏统计信息
self.stats.game_active = True
# 清空外星人和子弹列表
self.aliens.empty()
self.bullets.empty()
# 更新记分牌
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
# 创建一群新的外星人, 并将飞船放到屏幕底端中央
self.create_fleet()
self.ship.center_ship()
def fire_bullet(self, ):
"""
没有达到限制, 就发射一颗子弹
"""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def create_fleet(self, ):
"""
创建外星人群:
创建一个外星人, 计算每一行可容纳多少个外星人
外星人间距为外星人宽度
"""
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - 2 * alien_width # 屏幕2边空出一个外星人宽度
number_aliens_x = int(
available_space_x /
(2 * alien_width)) # 间距为外星人宽度, 所有个数=行宽/(2*alien_width)s
ship_height = self.ship.rect.height
available_space_y = self.settings.screen_height - 3 * alien_height - ship_height # 飞船上方留出空白
number_rows = int(
available_space_y /
(2 * alien_height)) # 间距为外星人高度, 行数=高/(2*alien_height)
# 创建外星人群
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self.create_alien(alien_number, row_number)
def create_alien(self, alien_number, row_number):
"""
创建一个外星人, 并放在相应位置
"""
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien_height * row_number
self.aliens.add(alien)
def update_bullets(self, ):
"""
更新子弹位置, 并删除已消失的子弹
检查是否击中外星人, 如果击中则删除应用的子弹和外星人
"""
self.bullets.update()
# 删除已消失(屏幕之外)的子弹
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self.check_bullet_alien_collisions()
def check_bullet_alien_collisions(self, ):
"""
检测子弹和外星人之间的碰撞, 删除发生碰撞的子弹和外星人
"""
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
# 如果击中外星人, 则更新得分和记分牌
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.high_score_check()
# 如果外星人为空, 删除所有子弹并创建新的外星人群
if len(self.aliens) == 0:
self.bullets.empty()
self.settings.increase_speed() # 加快游戏节奏
self.create_fleet()
# 外星人群被消灭, 提高一个等级, 更新等级及记分牌
self.stats.level += 1
self.sb.prep_level()
def updata_aliens(self, ):
"""
检查是否有外星人位于屏幕边缘, 并更新外星人群中所有外星人的位置
"""
self.check_fleet_edges()
self.aliens.update()
# 检测外星人和飞船之间的碰撞
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.ship_hit()
# 检查是否有外星人到达屏幕底端
self.check_aliens_bottom()
def check_fleet_edges(self, ):
"""
有外星人达到屏幕边缘时, 采取相应措施
"""
for alien in self.aliens.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
def change_fleet_direction(self, ):
"""
外星人群整体下移, 并改变移动方向
"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.alien_drop_speed
self.settings.fleet_direction *= -1
def ship_hit(self, ):
"""
响应飞船被撞, 飞船剩余数量-1
"""
self.stats.ships_left -= 1
if self.stats.ships_left > 0:
# self.stats.ships_left -= 1 # 此条件需放到比较之前, 当ships_left=1时, 该分支仍会执行, 但此时的飞船数已为0, 不应该继续执行
# 清空外星人和子弹列表
self.aliens.empty()
self.bullets.empty()
# 创建一群新的外星人, 并将飞船放到屏幕底端中央
self.create_fleet()
self.ship.center_ship()
# 暂停
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True) # 游戏处于非激活状态时, 显示光标
# 更新记分牌
self.sb.prep_ships()
def check_aliens_bottom(self, ):
"""
检查是否有外星人到达屏幕底端
"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# 只要有外星人到达屏幕底端, 则像飞船被撞一样处理
self.ship_hit()
break
def update_screen(self, ):
"""
更新屏幕上的图像, 并切换到新屏幕
"""
# 重新绘制屏幕
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
self.aliens.draw(self.screen)
# 在飞船和外星人后重绘所有子弹
for bullet in self.bullets.sprites():
bullet.draw_bullet()
# 显示得分
self.sb.show_score()
# 如果游戏处于非激活状态, 则绘制Play按钮
if not self.stats.game_active:
self.play_button.draw_button()
# 让最近绘制的屏幕可见
pygame.display.flip()
class Game(object):
title = 'Gravity'
screen_size = 1000, 750
def __init__(self,level=0):
pygame.init()
self.screen = pygame.display.set_mode(self.screen_size)
if self.title:
pygame.display.set_caption(self.title)
self.fps = 30
#group definitions
self.userPlacedObjects = Group()
self.startItems = RenderUpdates()
self.playerGroup = RenderUpdates()
self.tails = RenderUpdates()
self.blackHoles = RenderUpdates()
self.obstacles = RenderUpdates()
self.masslessObstacles = RenderUpdates()
self.goalCollide = Group()
self.toolbar = OrderedUpdates()
#level/transition/player & enemy/obstacle creation hocus pocus
self.goal = Goal(573,372,self.goalCollide,30)
self.bar = ToolBar(0,626,self.toolbar,self.screen,self,self.goal)
self.player = Player(50,535,self.screen,(255,0,0),self.playerGroup,1000,624,(2,-2),self.tails,self)
self.level = level
self.levelUp = True
self.stars = Starfield(self.screen,1000,626,200)
BlackHole(339,70,self.blackHoles,self.screen,80,71,16)
temp = EarthRounder(513,313,self.masslessObstacles,self.screen,40,0)
temp.rotate(55)
temp = Alien(60,188,self.masslessObstacles,self.screen,34,1)
temp.rotate(-15)
temp = Alien(107,268,self.masslessObstacles,self.screen,35,1)
temp.rotate(-75)
temp = Alien(816,533,self.masslessObstacles,self.screen,39,0)
temp.rotate(-13)
temp = BlueUpAnDown(811,227,self.masslessObstacles,self.screen,34,1,97,239)
temp.rotate(80)
self.obstacles.add(self.blackHoles)
self.obstacles.add(self.goalCollide)
self.freeb = False
self.gotoLevel = level
self.loaded = False
if system.thereIsASaveFile() and level == 0:
self.intro_screen = Intro(0,0,self.startItems,str('title_w_file.png'))
self.thereIsAFile = True
elif level == 0:
self.intro_screen = Intro(0,0,self.startItems)
self.thereIsAFile = False
def quit(self):
self.done = True
def level_0(self):
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()
elif evt.key == K_RETURN:
if not self.thereIsAFile:
self.transition = Transition(-1314,0,self.screen,self.startItems)
self.intro_screen.begin()
else:
loadingDial = system.Loading()
pygame.draw.rect(self.screen,(0,0,0),((0,0),(1000,750)))
self.startItems.draw(self.screen)
loadingDial.draw(self.screen)
pygame.display.flip()
self.loadFile(system.loadFile())
elif evt.key == K_RIGHT:
self.intro_screen.instruct(True)
elif evt.key == K_LEFT:
self.intro_screen.instruct(False)
elif evt.key == K_n:
if self.thereIsAFile:
self.transition = Transition(-1314,0,self.screen,self.startItems)
self.intro_screen.begin()
self.transition = Transition(-1314,0,self.screen,self.startItems)
elif evt.key == K_d:
if self.thereIsAFile:
os.remove('save.txt')
self.thereIsAFile = False
self.startItems.empty()
self.intro_screen = Intro(0,0,self.startItems)
if self.intro_screen.next_level():
self.level = 1
self.startItems.update()
self.stars.draw()
self.goalCollide.draw(self.screen)
self.toolbar.draw(self.screen)
self.masslessObstacles.draw(self.screen)
self.playerGroup.draw(self.screen)
self.blackHoles.draw(self.screen)
self.startItems.draw(self.screen)
pygame.display.flip()
def tick(self):
self.clock.tick(self.fps)
pygame.draw.rect(self.screen,(0,0,0),((0,0),(1000,750)))
pos = pygame.mouse.get_pos()
#inputs queue
for evt in pygame.event.get():
if evt.type == QUIT:
self.quit()
elif evt.type == KEYDOWN:
if evt.key == K_ESCAPE and not self.bar.itemsTab.open and self.bar.grabbed == None:
self.bar.menuWidget.dropped()
elif evt.key == K_ESCAPE and self.bar.grabbed == None:
self.bar.itemsTab.dropped()
self.bar.menuWidget.dropped()
elif evt.type == MOUSEBUTTONDOWN:
#print pos
should_freebie = self.bar.collision_test(pos,self.player,evt.button)
if should_freebie and not self.freeb:
self.freebie()
self.freeb = True
if evt.button == 1:
for obj in self.userPlacedObjects:
if obj.rect.collidepoint(pos) and not self.player.makeANew and not self.bar.menuWidget.open:
obj.grab(pos)
elif evt.button == 3:
for obj in self.userPlacedObjects:
if obj.rect.collidepoint(pos) and not self.player.makeANew and not self.bar.menuWidget.open:
obj.remove()
elif evt.type == MOUSEBUTTONUP:
self.bar.clear_grabbed()
for obj in self.userPlacedObjects:
obj.drop(self.blackHoles)
if self.level == 4 and self.player.makeANew:
self.masslessObstacles.update()
#self.masslessObstacles.update(self.player.makeANew)
self.stars.draw()
self.player.drawTails()
self.blackHoles.update()
self.bar.update(pos)
self.blackHoles.draw(self.screen)
self.userPlacedObjects.update(pos)
self.userPlacedObjects.draw(self.screen)
self.masslessObstacles.draw(self.screen)
self.goalCollide.draw(self.screen)
self.toolbar.draw(self.screen)
self.playerGroup.update()
self.playerGroup.draw(self.screen)
if len(self.playerGroup) == 0 and self.player.lives >1:
self.bar.lives_update()
self.bar.score.update(-200)
pygame.time.wait(750)
self.player.lives -= 1
if self.level == 4:
self.asteroid.reset()
self.player.add(self.playerGroup)
elif len(self.playerGroup) == 0:
self.bar.score.update(-200)
self.bar.lives_update()
self.over_screen = GameOverScreen(293,161,self.screen)
if self.level == 4:
self.asteroid.reset()
self.gameOver()
if pygame.sprite.collide_mask(self.player, self.goal):
if self.loaded != 0:
self.level = self.loaded
self.loaded = 0
self.next_level()
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)
pygame.display.flip()
def next_level(self,add_score_bool=True,trans_effect=True):
if self.level < 5:
print self.level,"pre-adding"
self.level += 1
print self.level,"post-adding"
#print self.level
if self.level == 5:
return
if trans_effect: self.transition.add_to_group()
changed = 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()
if not trans_effect or self.transition.rect.x >= -50 and not changed:
print self.level
if self.level == 2:
self.make_level_two(add_score_bool)
if self.level == 3:
self.make_level_three(add_score_bool)
if self.level == 4:
self.make_level_four(add_score_bool)
if add_score_bool:
self.bar.score.update(2000)
self.player.restart(add_score_bool)
changed = True
if not trans_effect:
print self.level,"load"
break
self.startItems.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.playerGroup.draw(self.screen)
self.startItems.draw(self.screen)
if self.transition.rect.x > 1000:
self.transition.kill()
break
pygame.display.flip()
if trans_effect:
self.transition.reset(-1314)
print self.level,"end o loop"
return False
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()
def gameOver(self):
overing = True
self.bar.update()
self.toolbar.draw(self.screen)
self.over_screen.draw()
pygame.display.flip()
while overing:
self.clock.tick(self.fps)
for evt in pygame.event.get():
if evt.type == QUIT:
overing = False
self.quit()
if evt.type == KEYDOWN:
if evt.key == K_ESCAPE:
overing = False
self.quit()
if evt.key == K_RETURN:
overing = False
self.player.add(self.playerGroup)
self.bar.reset_lives_over()
self.player.restart()
self.over_screen.kill()
def inStructionees(self):
self.instructions = Instructions(0,-750,self.startItems)
self.instructions.instruct(True)
while True:
self.clock.tick(self.fps)
pygame.draw.rect(self.screen,(0,0,0),((0,0),(1000,750)))
if self.instructions.instruct and self.instructions.rect.y < 0:
self.instructions.rect.y += 50
elif not self.instructions.instruct and self.instructions.rect.y > -750:
self.instructions.rect.y -= 50
elif not self.instructions.instruct and self.instructions.rect.y <= -750:
self.instructions.kill()
return
for evt in pygame.event.get():
if evt.type == QUIT:
self.quit()
return
elif evt.type == KEYDOWN:
if evt.key == K_RETURN:
self.instructions.instruct = False
elif evt.key == K_ESCAPE:
self.quit()
return
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.playerGroup.draw(self.screen)
self.startItems.draw(self.screen)
pygame.display.flip()
def saveFile(self):
save_confirm = GameOverScreen(293,161,self.screen,str('filesaved.png'))
save_confirm.draw()
self.bar.menuWidget.dropped()
system.saveFile(self.level,self.player.lives,self.bar.score.score)
pygame.display.flip()
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()
return
elif evt.type == KEYDOWN:
if evt.key == K_RETURN:
return
elif evt.key == K_ESCAPE:
self.quit()
return
def loadFile(self,file_tuple):
gotoLevel,gotoLives,gotoScore = file_tuple
self.level = gotoLevel
if self.level > 1:
self.loaded = self.level
self.player.lives = gotoLives
self.bar.lives.next_life = gotoLives+1
self.bar.lives_update()
self.bar.score.reset(gotoScore)
if gotoLevel != 1:
self.level -= 1
self.next_level(False,False)
self.startItems.empty()
self.intro_screen = Intro(0,0,self.startItems,str('title_w_file.png'))
self.intro_screen.begin()
self.transition = Transition(-1314,0,self.screen,self.startItems)
while True:
self.clock.tick(self.fps)
pygame.draw.rect(self.screen,(0,0,0),((0,0),(1000,750)))
if self.intro_screen.next_level():
break
self.startItems.update()
self.startItems.update()
self.stars.draw()
self.goalCollide.draw(self.screen)
self.toolbar.draw(self.screen)
self.masslessObstacles.draw(self.screen)
self.playerGroup.draw(self.screen)
self.blackHoles.draw(self.screen)
self.startItems.draw(self.screen)
pygame.display.flip()
def gameWinner(self):
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()
elif evt.type == KEYDOWN:
self.quit()
self.winnerScreen.draw()
pygame.display.flip()
def run(self,level=0):
self.done = False
self.clock = pygame.time.Clock()
if self.gotoLevel > 1 and self.gotoLevel < 4:
self.transition = Transition(-1314,0,self.screen,self.startItems)
self.tick()
self.level = self.gotoLevel
self.next_level()
while not self.done:
while self.level == 0 and not self.done:
self.level_0()
while self.level >= 1 and self.level < 5 and not self.done:
self.tick()
self.winnerScreen = WinScreen(0,0,self.screen)
while not self.done:
self.gameWinner()
def make_level_two(self,reset_lives_bool):
self.tails.empty()
self.goal.next_level(self.level)
self.bar.next_level(self.level,reset_lives_bool)
self.userPlacedObjects.empty()
self.blackHoles.empty()
self.obstacles.empty()
self.freeb = False
self.bar.itemsTab.earth_item.light()
self.masslessObstacles.empty()
temp = Alien(55,143,self.masslessObstacles,self.screen,39,1)
temp.rotate(-66)
temp = Alien(189,98,self.masslessObstacles,self.screen,36,1)
temp.rotate(23)
temp = Alien(107,228,self.masslessObstacles,self.screen,32,1)
temp.rotate(17)
temp = BlueUpAnDown(249,244,self.masslessObstacles,self.screen,41,1,204,245)
temp.rotate(80)
temp = TwitchyOnes(898,541,self.masslessObstacles,self.screen,45,2)
temp.rotate(22)
temp = TwitchyOnes(730,545,self.masslessObstacles,self.screen,40,2)
temp.rotate(-30)
temp = Rotator(525,121,self.masslessObstacles,self.screen,50,0,-70)
BlackHole(842,388,self.blackHoles,self.screen,80,71,16)
hole = BlackHole(388,189,self.blackHoles,self.screen,80,71,16)
hole.flip()
self.obstacles.add(self.blackHoles)
self.obstacles.add(self.goal)
def make_level_three(self,reset_lives_bool):
self.goal.next_level(self.level)
self.bar.next_level(self.level,reset_lives_bool)
self.userPlacedObjects.empty()
self.blackHoles.empty()
self.obstacles.empty()
self.freeb = False
self.bar.itemsTab.earth_item.light()
self.masslessObstacles.empty()
temp = Alien(519,257,self.masslessObstacles,self.screen,28,3)
temp.rotate(18)
temp = Alien(539,247,self.masslessObstacles,self.screen,27,3)
temp.rotate(60)
temp = Alien(555,240,self.masslessObstacles,self.screen,25,3)
temp.rotate(-20)
temp = Alien(568,281,self.masslessObstacles,self.screen,29,3)
temp.rotate(-45)
temp = Alien(549,291,self.masslessObstacles,self.screen,32,3)
temp.rotate(10)
temp = Alien(530,301,self.masslessObstacles,self.screen,26,3)
temp = Alien(562,265,self.masslessObstacles,self.screen,27,3)
temp.rotate(25)
temp = Alien(519,334,self.masslessObstacles,self.screen,25,3)
temp.rotate(-70)
temp = Alien(500,307,self.masslessObstacles,self.screen,25,3)
temp.rotate(-80)
temp = Alien(494,356,self.masslessObstacles,self.screen,25,3)
temp.rotate(-3)
temp = Alien(560,365,self.masslessObstacles,self.screen,25,3)
temp.rotate(77)
temp = Alien(525,374,self.masslessObstacles,self.screen,29,3)
temp.rotate(33)
temp = Alien(640,290,self.masslessObstacles,self.screen,26,3)
temp.rotate(37)
temp = Alien(607,250,self.masslessObstacles,self.screen,33,3)
temp.rotate(-27)
temp = Alien(518,421,self.masslessObstacles,self.screen,24,3)
temp.rotate(55)
temp = Alien(473,419,self.masslessObstacles,self.screen,28,3)
temp.rotate(-43)
temp = Alien(480,453,self.masslessObstacles,self.screen,27,3)
temp = Alien(512,479,self.masslessObstacles,self.screen,31,3)
temp.rotate(4)
temp = Alien(422,500,self.masslessObstacles,self.screen,32,3)
temp = Alien(463,521,self.masslessObstacles,self.screen,27,3)
temp.rotate(22)
temp = Alien(471,486,self.masslessObstacles,self.screen,22,3)
temp.rotate(80)
temp = Alien(743,713,self.masslessObstacles,self.screen,25,3)
temp.rotate(13)
temp = Alien(527,532,self.masslessObstacles,self.screen,28,3)
temp.rotate(-8)
temp = Alien(568,559,self.masslessObstacles,self.screen,27,3)
temp = Alien(527,593,self.masslessObstacles,self.screen,23,3)
temp.rotate(-60)
temp = Alien(652,552,self.masslessObstacles,self.screen,25,3)
temp.rotate(-24)
temp = Alien(636,581,self.masslessObstacles,self.screen,26,3)
temp.rotate(-19)
temp = Alien(714,596,self.masslessObstacles,self.screen,22,3)
temp.rotate(-88)
BlackHole(162,42,self.blackHoles,self.screen,80,71,29)
self.obstacles.add(self.goal)
self.obstacles.add(self.blackHoles)
def make_level_four(self,reset_lives_bool):
self.goal.next_level(self.level)
self.bar.next_level(self.level,reset_lives_bool)
self.userPlacedObjects.empty()
self.blackHoles.empty()
self.obstacles.empty()
self.freeb = False
self.bar.itemsTab.earth_item.light()
self.masslessObstacles.empty()
BlackHole(183,61,self.blackHoles,self.screen,80,71,16)
BlackHole(101,157,self.blackHoles,self.screen,80,71,16)
BlackHole(234,157,self.blackHoles,self.screen,80,71,16)
BlackHole(178,250,self.blackHoles,self.screen,80,71,16)
hole = BlackHole(683,41,self.blackHoles,self.screen,80,71,16)
hole = BlackHole(577,41,self.blackHoles,self.screen,80,71,16)
hole = BlackHole(646,133,self.blackHoles,self.screen,80,71,16)
hole = BlackHole(747,133,self.blackHoles,self.screen,80,71,16)
self.asteroid = Asteroid(840,530,self.masslessObstacles,self.screen,55,4)
self.asteroid.rotate(137)
self.obstacles.add(self.blackHoles)
self.obstacles.add(self.goal)
rungame = True
sounds.stage_clear.play()
# Set the two while loops to start mainMenu first
while rungame:
# Set to true to run main game loop
bMenu.setMenuButtons(mainMenuButtons)
while stats.mainMenu:
if not stats.gameActive and stats.paused:
setting.initDynamicSettings()
stats.resetStats()
##stats.gameActive = True
# Reset the alien and the bullets
aliens.empty()
bullets.empty()
eBullets.empty()
# Create a new fleet and center the ship
gf.createFleet(setting, stats, screen, ship, aliens)
ship.centerShip()
mm.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens, bullets, eBullets)
mm.drawMenu(setting, screen, sb, bMenu, bgImage, bgImageRect)
bMenu.setMenuButtons(levelMenuButtons)
while stats.levelMenu:
lm.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens, bullets, eBullets)
lm.drawMenu(setting, screen, sb, bMenu, bgImage, bgImageRect)
class Game:
def __init__(self):
pygame.init()
self.surface = pygame.display.set_mode((480, 852))
pygame.display.set_caption("Plane Wars")
try:
icon = pygame.image.load("../res/image/icon.ico")
except pygame.error:
pass
else:
pygame.display.set_icon(icon)
self.clock = pygame.time.Clock()
self.stats = Stats()
self.bg = Background()
self.hero = Hero(self.surface.get_rect(), self.stats)
self.bullets = Group()
self.enemies = Group()
buttons_name = ["Start", "Restart", "Exit"]
self.buttons = {
name: Button(self.surface.get_rect(), name)
for name in buttons_name
}
widgets_name = ["Logo", "EndPrompt", "Scoreboard", "PauseResume"]
self.widgets = {
name: eval(name)(self.surface.get_rect(), self.stats)
for name in widgets_name
}
self.sounds = Sound()
self.frames = 0
def reset(self):
self.stats.reset()
self.hero.reset()
self.widgets["PauseResume"].reset()
def run(self):
while True:
self.handle_events()
if self.stats.state == Stats.RUN:
self.bg.update()
self.update_bullets()
self.update_enemies()
self.handle_collision()
self.update_screen()
self.clock.tick(60)
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
self.handle_mousedown_event(event)
elif event.type == pygame.MOUSEMOTION:
self.handle_mousemotion_event(event)
def handle_mousedown_event(self, event):
if self.stats.state == Stats.WELCOME:
if self.buttons["Start"].is_hit(event.pos):
self.stats.state = Stats.RUN
# play background music indefinitely
self.sounds.play("bg")
elif self.stats.state == Stats.RUN:
if self.widgets["PauseResume"].is_hit(event.pos):
self.widgets["PauseResume"].update_click()
self.stats.state = Stats.PAUSE
self.sounds.pause("bg")
elif self.stats.state == Stats.PAUSE:
if self.widgets["PauseResume"].is_hit(event.pos):
self.widgets["PauseResume"].update_click()
self.stats.state = Stats.RUN
self.sounds.unpause("bg")
elif self.stats.state == Stats.GAMEOVER:
if self.buttons["Restart"].is_hit(event.pos):
self.reset()
self.stats.state = Stats.RUN
self.sounds.play("bg")
elif self.buttons["Exit"].is_hit(event.pos):
pygame.quit()
sys.exit()
def handle_mousemotion_event(self, event):
if self.stats.state == Stats.RUN:
if event.buttons[0]:
self.hero.update(event.pos)
self.widgets["PauseResume"].update_mouse_motion(event.pos)
elif self.stats.state == Stats.PAUSE:
self.widgets["PauseResume"].update_mouse_motion(event.pos)
def update_bullets(self):
# create bullet
self.frames += 1
if not (self.frames % 5):
self.bullets.add(Bullet(self.hero.rect))
self.sounds.play("bullet")
# move bullets
self.bullets.update()
def update_enemies(self):
if len(self.enemies) < 18:
screen_rect = self.surface.get_rect()
weighted_list = [EnemySmall] * 30 + [EnemyMiddle] * 3 + [EnemyBig
] * 1
enemy = random.choice(weighted_list)
left = random.randint(0,
screen_rect.width - enemy.get_max_size()[0])
top = random.randint(-screen_rect.height, -enemy.get_max_size()[1])
self.enemies.add(enemy((left, top), screen_rect, self.stats))
self.enemies.update()
def handle_collision(self):
# check bullets & enemies collision
collide_dict = pygame.sprite.groupcollide(self.bullets, self.enemies,
True, False,
pygame.sprite.collide_mask)
collide_enemies_list = []
if collide_dict:
for collide_enemies in collide_dict.values():
collide_enemies_list.extend(collide_enemies)
if collide_enemies_list:
for collide_enemy in collide_enemies_list:
if collide_enemy.current_hp == 1:
self.sounds.play("enemy" + str(collide_enemy.type) +
"_down")
collide_enemy.hit_by_bullet()
# check hero & enemies collision
enemy = pygame.sprite.spritecollideany(self.hero, self.enemies,
pygame.sprite.collide_mask)
if enemy:
self.hero.is_collide = True
self.bullets.empty()
self.enemies.empty()
self.widgets["EndPrompt"].update_score_num()
self.sounds.fadeout("bg")
self.sounds.play("game_over")
def update_screen(self):
# draw background image onto display surface
self.bg.draw(self.surface)
if self.stats.state == Stats.WELCOME:
# welcome state
self.widgets["Logo"].draw(self.surface)
self.buttons["Start"].draw(self.surface)
elif self.stats.state == Stats.RUN or self.stats.state == Stats.PAUSE:
# run/pause state
self.hero.draw(self.surface)
self.bullets.draw(self.surface)
self.enemies.draw(self.surface)
# draw pause button and score at last, keeps them above the screen
self.widgets["PauseResume"].draw(self.surface)
self.widgets["Scoreboard"].draw(self.surface)
elif self.stats.state == Stats.GAMEOVER:
# game over state
self.widgets["EndPrompt"].draw(self.surface)
self.buttons["Restart"].draw(self.surface)
self.buttons["Exit"].draw(self.surface)
# update display surface
pygame.display.flip()
class AlienGame():
def __init__(self, screen, game_settings):
""" Конструктор класса игры"""
self.game_settings = game_settings
self.screen = screen
# Создание объекта статистики игры
self.stats = GameStats(game_settings)
self.sb = Scoreboard(game_settings, screen, self.stats)
# Создание корабля
self.ship = Ship(game_settings, screen)
# Создание пришельца
self.aliens = Group()
# Создание флота пришельцев
self.create_fleet()
# Создание группы для хранения пуль
self.bullets = Group()
# Создание кнопки Play
self.play_button = Button(game_settings, screen, "Play")
def check_keydown_events(self, event):
""" Реагирует на нажатие клавиш"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_SPACE:
self.fire_bullet()
elif event.key == pygame.K_ESCAPE:
sys.exit()
def fire_bullet(self):
# Создание новой пули и включение в группу bullets
if len(self.bullets) < self.game_settings.bullets_allowed:
new_bullet = Bullet(self.game_settings, self.screen, self.ship)
self.bullets.add(new_bullet)
def check_keyup_events(self, event):
""" Реагирует на отпускание клавиш """
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def check_events(self):
""" Отслеживание событий клавиатуры и мыши"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self.check_keydown_events(event)
elif event.type == pygame.KEYUP:
self.check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
self.check_play_button(mouse_x, mouse_y)
def check_play_button(self, mouse_x, mouse_y):
""" Запускает новую игру при нажатии кнопки Play """
button_clicked = self.play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not self.stats.game_active:
# Сброс игровых настроек
self.game_settings.initialize_dynamic_settings()
# Скрываем указатель мыши
pygame.mouse.set_visible(False)
# Сброс игровой статистики
self.stats.reset_stats()
self.sb.prep_score()
self.sb.prep_high_score()
self.sb.prep_level()
self.sb.prep_ships()
self.stats.game_active = True
# Очистка пришельцев и пуль
self.aliens.empty()
self.bullets.empty()
# Создание флота и корабля в центре
self.create_fleet()
self.ship.center_ship()
def update_screen(self):
""" Обновляет изображение на экране """
self.screen.fill(self.game_settings.bg_color)
# Все пули позади корабля и пришельцев
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.ship.blitme()
self.aliens.draw(self.screen)
# Вывод счета
self.sb.show_score()
# Кнопка Play отображается, если игра неактивна
if not self.stats.game_active:
self.play_button.draw_button()
# Отображение последнего прорисованного экрана
pygame.display.flip()
def update_bullets(self):
""" Обновляет пули """
self.bullets.update()
# Удаление пуль, вышедших за край экрана
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self.check_bullet_alien_collisions()
def check_bullet_alien_collisions(self):
# Проверка попаданий в пришельцев
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
for aliens in collisions.values():
self.stats.score += self.game_settings.alien_points * len(
aliens)
self.sb.prep_score()
self.check_high_score()
if len(self.aliens) == 0:
# Уничтожение существующих пуль и создание нового флота
self.bullets.empty()
self.game_settings.increase_speed()
# Увеличение уровня
self.stats.level += 1
self.sb.prep_level()
self.create_fleet()
def get_number_aliens_x(self, alien_width):
""" Вычисляет количество пришельцев в ряду """
available_space_x = self.game_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / (2 * alien_width))
return number_aliens_x
def get_number_rows(self, ship_height, alien_height):
""" Определяет количество рядов флота пришельцев"""
available_space_y = self.game_settings.screen_height - 3 * alien_height - ship_height
number_rows = int(available_space_y / (2 * alien_height))
return number_rows
def create_alien(self, alien_number, row_number):
# Создание пришельца и размещение его в ряду
alien = Alien(self.game_settings, self.screen)
alien_width = alien.rect.width
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def create_fleet(self):
""" Создает флот пришельцев """
# Вычисление количества пришельцев
alien = Alien(self.game_settings, self.screen)
number_aliens_x = self.get_number_aliens_x(alien.rect.width)
number_rows = self.get_number_rows(self.ship.rect.height,
alien.rect.height)
# Создание флота пришельцев
for row_number in range(number_rows):
# Создание ряда пришельцев
for alien_number in range(number_aliens_x):
self.create_alien(alien_number, row_number)
def update_aliens(self):
""" Обновление позиции всех пришельцев"""
self.check_fleet_edges()
self.aliens.update()
# Проверка коллизий пришелец-корабль
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.ship_hit()
# Проверка достижения нижнего края пришельцами
self.check_aliens_bottom()
def check_aliens_bottom(self):
""" Проверяет, дорались ли пришельцы до нижнего края"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self.ship_hit()
break
def ship_hit(self):
""" Обрабатывает столкновение корабля с пришельцем"""
if self.stats.ships_left > 0:
self.stats.ships_left -= 1
self.sb.prep_ships()
self.aliens.empty()
self.bullets.empty()
self.create_fleet()
self.ship.center_ship()
# Пауза
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def check_fleet_edges(self):
""" Реагирует на достижение флотом края экрана"""
for alien in self.aliens.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
def change_fleet_direction(self):
""" Изменяет направление флота"""
for alien in self.aliens.sprites():
alien.rect.y += self.game_settings.fleet_drop_speed
self.game_settings.fleet_direction *= -1
def check_high_score(self):
""" Проверяет, появился ли новый рекорд """
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.sb.prep_high_score()
message_group.add(pl) # добавляем объект в группу сообщения
message_list.append(pl) # добавляем объект в список сообщения, который нужен для передачи в шифрующую функцию
messx += PL_W
# обновляем все объекты группы сообщения (вызываем метод update)
for i in message_group:
i.update()
for i in button_group: # перебираем объекты группы кнопок управления
i.update() # вызывем для каждого объекта метод update
if i.onClick(mouse_click): # проверяем было ли нажатие по данной кнопке
if i.text == 'Зашифровать': # если было нажатие и текст кнопки = Зашифровать
message_list = encode() # то вызываем функцию шифрования
if i.text == 'Стереть': # если текст кнопки = Стереть
# очищаем все группы кроме групп алфавита и кнопок управления
message_group.empty()
messx = 150 # задаем начальное положение отображения сообщения
encode_message_group.empty()
message_list = [] # обнуляем список объектов для дешифрования
decode_message.empty()
if i.text == 'Дешифровать': # если текст кнопки = Дешифровать
decode(message_list) # вызываем функцию дешифрования
if i.text == 'Показать коды': # если текст = Показать коды
i.text = i.alt_text # меняем текст данной кнопки на альтернативный
show_codes([message_group, encode_message_group, decode_message]) # вызываем функцию show_codes передавая ей все группы кнопок коды которых нужно показать
elif i.text == 'Показать текст': # если текст кнопки = Показать текст
i.text = 'Показать коды' # меняем основной текст на Показать коды
show_text([message_group, encode_message_group, decode_message]) # вызываем функцию show_text и передаем ей все группы кнопок текст которых нужно отобразить
# обновляем все объекты группы зашифрованного сообщения (вызываем метод update)
for i in encode_message_group:
class Game(Application.State):
fps = 60
CHEAT = [ K_UP, K_UP, K_DOWN, K_DOWN, K_LEFT, K_RIGHT, K_LEFT, K_RIGHT, K_b, K_a ]
def setup(self):
scr_size = self.app.screen.get_size()
self.level = Level(scr_size)
self.level.restart()
self.cheat_idx = 0
self.background = TiledImage(load_image("grass"))
# makes things look a bit nicer for some reason
w = self.background.rect.width
self.background.rect.move_ip(-w/2, -w/2)
self.l_shadow = ShadowLayer(scr_size)
self.l_sprite = Layer(scr_size)
self.sprites = Group()
self.app.scores.reset()
self.font = pygame.font.Font(None, 60)
self.cheating = False
play_song("maintheme", volume=0.7)
def resume(self):
self.clock = pygame.time.Clock()
pygame.mixer.music.unpause()
def pause(self):
pygame.mixer.music.pause()
def handle_event(self, event):
if event.type == KEYDOWN and event.key == K_ESCAPE:
self.level.player.cheating = False
self.app.set_state(PauseMenu)
elif event.type == KEYDOWN and event.key == self.CHEAT[self.cheat_idx]:
self.cheat_idx += 1
elif event.type == KEYDOWN:
self.cheat_idx = 0
if self.cheat_idx == len(self.CHEAT):
self.cheat_idx = 0
self.level.player.cheating = not self.level.player.cheating
def update(self):
dt = self.clock.tick(self.fps)
self.level.update(dt)
if self.level.player.cheating:
self.cheating = True
elif not self.level.player.cheating and len(self.level.coins) == 1:
self.cheating = False
if not self.cheating:
self.app.scores.update( len(self.level.coins) )
else:
self.app.scores.update(-1)
def draw(self, screen):
self.l_shadow.clear()
self.l_sprite.clear()
# switch to layers
screen.fill((80,80,80))
self.background.draw(screen)
# create a list of sprites we need to draw
self.sprites.empty()
self.sprites.add(self.level.player)
for coin in self.level.coins:
if coin.visible:
self.sprites.add(coin)
# sort the sprites by their height
sprites = sorted(self.sprites, sortby_y_h)
self.l_shadow.draw_sprites(sprites)
self.l_sprite.draw_sprites(sprites)
self.l_shadow.draw(screen)
self.l_sprite.draw(screen)
# draw score
score = self.font.render("Coins: %d" % self.app.scores.score, True, (255,255,255))
rect = score.get_rect()
rect.bottomleft = screen.get_rect().bottomleft
screen.blit(score, rect)
hiscore = self.font.render("Hiscore: %d" % self.app.scores.hiscore, True, (255,255,255))
rect = hiscore.get_rect()
rect.bottomright = screen.get_rect().bottomright
screen.blit(hiscore, rect)
class Level(GameState):
"""Level is a GameState with behavior for one full game level.
Contains Sprites player, enemy, shield, hbullet, cannon, and Group player_bullets
"""
def __init__(self, manager):
"""manager is required to be a child of GameManager with these functions:
-kill_player()
-next_level()
-add_score(amount)
-give_energy(amount)
-spend_energy(amount)
-give_life()
"""
GameState.__init__(self, manager)
self.player = Ship(*opt.player_args)
self.enemy = EnemyBase(opt.mover_args, opt.spinner_args, opt.shooter_args, self.player)
self.shield = EnemyShield(self.enemy, opt.shield_filename, formation, formation_center)
self.hbullet = HomingBullet(opt.homer_filename, self.player, opt.homer_speed)
self.cannon = Cannon(opt.deactivated_cannon_args, opt.standby_cannon_args,
opt.firing_cannon_args, self.player)
self.ion_field = IonField(*opt.ion_field_args)
self.player_bullets = Group()
self.reset_positions()
def update(self):
self.player.update()
self.enemy.update()
self.shield.update()
self.hbullet.update()
self.cannon.update()
self.player_bullets.update()
self.ion_field.update()
self.collisions()
def handle_events(self, events, keys):
return (event_handlers.check_quit(events, keys) and
event_handlers.check_shoot_button(events, keys, self.shoot) and
event_handlers.move_player(events, keys, self.player))
def draw(self, screen):
self.ion_field.draw(screen)
self.enemy.draw(screen)
self.shield.draw(screen)
self.player.draw(screen)
self.hbullet.draw(screen)
self.cannon.draw(screen)
self.player_bullets.draw(screen)
def collisions(self):
"""Handles collisions
"""
player = self.player
enemy = self.enemy
shield = self.shield
hbullet = self.hbullet
cannon = self.cannon
ion_field = self.ion_field
player_bullets = self.player_bullets
#player with homing bullet
if collide_mask(player, hbullet) and not collide_mask(player, ion_field):
self.kill_player()
#player with enemy base
if collide_mask(player, enemy):
#if base in moving phase, give player energy
if enemy.get_state_number() == EnemyBase.MOVING:
self.manager.give_energy(opt.energy_from_enemy)
#if base in spinning or shooting phase, kill player
elif enemy.get_state_number() == EnemyBase.SPINNING:
self.kill_player()
elif enemy.get_state_number() == EnemyBase.SHOOTING:
self.kill_player()
#player with cell
#-hitting a cell will bounce the player a bit to the left
#-if the player hit the cell twice in a short enough span,
# the cell is eaten and the player gets energy
#-in case of multiple collisions, deal with cell closest to player's center
#
#TODO: This still isn't quite right.
#Should be able to eat top/bottom rows with diagonal movement.
#(vertical movement should still move player all the way left)
pc_collides = spritecollide(player, shield, False, collide_mask)
center_cell = self.find_centermost_cell(pc_collides)
if center_cell is not None:
player.rect.right = center_cell.rect.left - opt.cell_bounceback
if not center_cell.marked:
center_cell.mark()
elif shield.can_eat():
center_cell.kill()
self.manager.give_energy(opt.energy_from_cell)
self.manager.add_score(opt.score_cell_eat)
shield.start_delay(opt.frames_to_eat_cell)
#player with cannon
if collide_mask(player, cannon):
#if in deactivated phase, try spending required energy to activate
if (cannon.get_state_number() == Cannon.DEACTIVATED and
self.manager.spend_energy(opt.cannon_energy_cost)):
cannon.start_standby()
#if in firing phase, kill player
if cannon.get_state_number() == Cannon.FIRING:
self.kill_player()
#if in returning phase, give energy and deactivate cannon
if cannon.get_state_number() == Cannon.RETURNING:
cannon.start_transition(Cannon.DEACTIVATED)
self.manager.give_energy(opt.energy_from_cannon)
#cannon with cell
#kill one cell and reverse cannon direction
#assuming this is only possible if cannon in firing state
if cannon.get_state_number() == Cannon.FIRING:
cannon_collides = spritecollide(cannon, shield, False, collide_mask)
if len(cannon_collides) > 0:
cannon_collides[0].kill()
self.manager.add_score(opt.score_cell_shoot)
cannon.start_transition(Cannon.RETURNING)
#cannon with enemy base -- only if cannon in firing state
#give points corresponding to enemy state and end level
#if enemy base is in shooting state, player also gets a life
if cannon.get_state_number() == Cannon.FIRING and collide_mask(cannon, enemy):
if enemy.get_state_number() == EnemyBase.MOVING:
self.manager.add_score(opt.score_mover_destroy)
elif enemy.get_state_number() == EnemyBase.SPINNING:
self.manager.add_score(opt.score_spinner_destroy)
elif enemy.get_state_number() == EnemyBase.SHOOTING:
self.manager.add_score(opt.score_shooter_destroy)
self.manager.give_life()
self.end_level()
#player's bullet with cell
#kill player bullet but remove cells in a cross pattern
#if somehow one bullet hits multiple cells one is arbitrarily selected
bc_collides = groupcollide(player_bullets, shield, True, False, collide_mask)
for current_bullet in bc_collides.keys():
self.manager.add_score(opt.score_cell_shoot)
shield.remove_cross(bc_collides[current_bullet][0])
def find_centermost_cell(self, cells):
"""Given a list of Cell sprites,
returns the one whose rect.centery is closest to the player's rect.centery
Returns None if list is empty
"""
closest_cell = None
for current_cell in cells:
current_dist = abs(current_cell.rect.centery - self.player.rect.centery)
if closest_cell is None or current_dist < closest_dist:
closest_cell = current_cell
closest_dist = current_dist
return closest_cell
def shoot(self):
"""If cannon can be fired, fires cannon.
Otherwise creates bullet moving from player's center along player's direction
as long as options.max_player_bullets won't be exeeded
"""
if collide_mask(self.player, self.ion_field):
return
if self.cannon.start_transition(Cannon.FIRING):
return
if len(self.player_bullets) < opt.max_player_bullets:
new_bullet = Bullet(opt.bullet_filename, opt.bullet_speed,
self.player.get_rect().center, self.player.get_direction())
self.player_bullets.add(new_bullet)
def reset_positions(self):
"""Moves sprites to their initial locations:
player starts in left center facing south and with 0 energy
player bullets are removed
enemy bullet starts on enemy base
enemy base is in moving state
cannon is in deactivated state
Note: shield configuration is not reset
"""
self.player.rect.midleft = (20, int(opt.height/2))
self.player.set_direction(vector.SOUTH)
self.player_bullets.empty()
self.enemy.resume_mover_state()
self.cannon.start_deactivated()
self.hbullet.rect.center = self.enemy.rect.center
def kill_player(self):
death_animation = DeathAnimation(self.manager, self.player, (self.enemy, self.shield), self,
opt.death_animation_delay, opt.death_animation_total_runtime)
self.manager.change_state(death_animation)
def end_level(self):
win_animation = WinAnimation(self.manager, self.player, opt.win_animation_total_runtime, opt.exp_field_args)
self.manager.change_state(win_animation)
class AlienInvasion:
"""
Class representing the game.
"""
def __init__(self):
"""
Initialize game object
"""
# Initialize game and create a screen object.
pygame.init()
# Initialize settings and screen object.
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
self.play_button = Button(self, "Play")
# create the Ship.
self.ship = Ship(self.settings, self.screen)
# Make a group to store the bullets.
self.bullets = Group()
self.aliens = Group()
self.create_fleet()
# Create a Game stats and scoreboard instance.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.game_paused = True
def run_game(self):
"""
Main function to be executed.
"""
# Start the main loop for the game.
while True:
self.check_events()
if self.stats.game_active and self.game_paused:
self.ship.update()
self.update_bullets()
self.update_aliens()
self.update_screen()
def get_number_of_rows(self, ship_height, alien_height):
"""
Determine the number of rows of aliens that fit on the screen.
"""
available_space_y = self.settings.screen_height - 3 * alien_height - ship_height
number_of_rows = int(available_space_y / (2 * alien_height))
return number_of_rows
def get_number_of_aliens_x(self, alien_width):
"""
Determine the number of aliens that fit in a row.
"""
available_space_x = self.settings.screen_width - 2 * alien_width
number_of_aliens_x = int(available_space_x / (2 * alien_width))
return number_of_aliens_x
def create_alien(self, alien_number, row_number):
"""
Create one alien.
"""
alien = Alien(self)
alien_width = alien.rect.width
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def create_fleet(self):
"""
Create a full fleet of aliens.
"""
# Create one alien to check the size and the number.
alien = Alien(self)
number_of_aliens_x = self.get_number_of_aliens_x(alien.rect.width)
number_of_rows = self.get_number_of_rows(self.ship.rect.height,
alien.rect.height)
# Create the fleet of the aliens.
for row_number in range(number_of_rows):
for alien_number in range(number_of_aliens_x):
self.create_alien(alien_number, row_number)
def check_key_down_events(self, event):
"""
Respond to key presses.
"""
if event.key == pygame.K_RIGHT:
# Move the ship to the right.
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_SPACE:
self.fire_bullet()
elif event.key == pygame.K_p:
self.start_game()
def check_key_up_events(self, event):
"""
Respond to key releases.
"""
if event.key == pygame.K_RIGHT:
# Move the ship to the right.
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
elif event.key == pygame.K_ESCAPE:
self.game_paused = not self.game_paused
def check_events(self):
"""
Respond to key presses and mouse events.
"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.settings.update_high_score(self)
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self.check_play_button(mouse_pos)
elif event.type == pygame.KEYDOWN:
self.check_key_down_events(event)
elif event.type == pygame.KEYUP:
self.check_key_up_events(event)
def check_play_button(self, mouse_pos):
"""
Start the new game if play was clicked.
"""
mouse_x, mouse_y = mouse_pos
button_clicked = self.play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked:
self.start_game()
def start_game(self):
"""
Start a new game.
"""
if not self.stats.game_active:
self.stats.game_active = True
pygame.mouse.set_visible(False)
self.stats.reset_stats()
# Empty the list of aliens and bullets.
self.aliens.empty()
self.bullets.empty()
self.sb.prep_all()
# Create a new fleet and center the ship.
self.create_fleet()
self.ship.center_ship()
def update_bullets(self):
"""
Update position of bullets and get rid of old ones.
"""
# Update bullets position.
self.bullets.update()
# Get rid of bullets that have disappeared.
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self.check_bullet_alien_collisions()
def check_bullet_alien_collisions(self):
"""
Respond to bullet-alien collisions.
"""
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_reward * len(aliens)
self.sb.prep_score()
self.check_high_score()
if len(self.aliens) == 0:
# Destroy all bullets and create a new fleet.
self.bullets.empty()
self.settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
self.create_fleet()
def fire_bullet(self):
"""
Fire a bullet if the limit is not yet reached.
"""
if len(self.bullets
) < self.settings.bullets_allowed and self.stats.game_active:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def update_screen(self):
"""
Update images on the screen and flip to the new screen.
"""
# Redraw the screen during each pass through the loop.
self.screen.fill(self.settings.bg_color)
self.sb.show_score()
if self.stats.game_active:
# Redraw all bullets behind ship and aliens.
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.ship.blitme()
self.aliens.draw(self.screen)
else:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
pygame.display.flip()
def check_fleet_edges(self):
"""
Respond properly if any alien 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.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def update_aliens(self):
"""
Check if the fleet is at an edge, and then update the positions.
"""
self.check_fleet_edges()
self.aliens.update()
# Now check for alien ship collisions.
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.lose_a_life()
# Check if aliens hit the bottom.
self.check_aliens_bottom()
def lose_a_life(self):
"""
Respond to ship being hit by alien.
"""
if self.stats.ships_left > 0:
# Decrement the number of ships left.
self.stats.ships_left -= 1
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
# Empty the list of aliens and bullets.
self.aliens.empty()
self.bullets.empty()
self.sb.prep_ships()
# Create a new fleet and center the ship.
self.create_fleet()
self.ship.center_ship()
sleep(0.5)
def check_aliens_bottom(self):
"""
Check if aliens hit the bottom.
"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# Treat this a loosing a life.
self.lose_a_life()
break
def check_high_score(self):
"""
Check to see if there is a new high score.
"""
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.sb.prep_high_score()
class Level(GameState):
"""Level is a GameState with behavior for one full game level.
Contains Sprites player, enemy, shield, hbullet, cannon, and Group player_bullets
"""
def __init__(self, manager):
"""manager is required to be a child of GameManager with these functions:
-kill_player()
-next_level()
-add_score(amount)
-give_energy(amount)
-spend_energy(amount)
-give_life()
"""
GameState.__init__(self, manager)
self.player = Ship(*opt.player_args)
self.enemy = EnemyBase(opt.mover_args, opt.spinner_args,
opt.shooter_args, self.player)
self.shield = EnemyShield(self.enemy, opt.shield_filename, formation,
formation_center)
self.hbullet = HomingBullet(opt.homer_filename, self.player,
opt.homer_speed)
self.cannon = Cannon(opt.deactivated_cannon_args,
opt.standby_cannon_args, opt.firing_cannon_args,
self.player)
self.ion_field = IonField(*opt.ion_field_args)
self.player_bullets = Group()
self.reset_positions()
def update(self):
self.player.update()
self.enemy.update()
self.shield.update()
self.hbullet.update()
self.cannon.update()
self.player_bullets.update()
self.ion_field.update()
self.collisions()
def handle_events(self, events, keys):
return (event_handlers.check_quit(events, keys)
and event_handlers.check_shoot_button(events, keys, self.shoot)
and event_handlers.move_player(events, keys, self.player))
def draw(self, screen):
self.ion_field.draw(screen)
self.enemy.draw(screen)
self.shield.draw(screen)
self.player.draw(screen)
self.hbullet.draw(screen)
self.cannon.draw(screen)
self.player_bullets.draw(screen)
def collisions(self):
"""Handles collisions
"""
player = self.player
enemy = self.enemy
shield = self.shield
hbullet = self.hbullet
cannon = self.cannon
ion_field = self.ion_field
player_bullets = self.player_bullets
#player with homing bullet
if collide_mask(player,
hbullet) and not collide_mask(player, ion_field):
self.kill_player()
#player with enemy base
if collide_mask(player, enemy):
#if base in moving phase, give player energy
if enemy.get_state_number() == EnemyBase.MOVING:
self.manager.give_energy(opt.energy_from_enemy)
#if base in spinning or shooting phase, kill player
elif enemy.get_state_number() == EnemyBase.SPINNING:
self.kill_player()
elif enemy.get_state_number() == EnemyBase.SHOOTING:
self.kill_player()
#player with cell
#-hitting a cell will bounce the player a bit to the left
#-if the player hit the cell twice in a short enough span,
# the cell is eaten and the player gets energy
#-in case of multiple collisions, deal with cell closest to player's center
#
#TODO: This still isn't quite right.
#Should be able to eat top/bottom rows with diagonal movement.
#(vertical movement should still move player all the way left)
pc_collides = spritecollide(player, shield, False, collide_mask)
center_cell = self.find_centermost_cell(pc_collides)
if center_cell is not None:
player.rect.right = center_cell.rect.left - opt.cell_bounceback
if not center_cell.marked:
center_cell.mark()
elif shield.can_eat():
center_cell.kill()
self.manager.give_energy(opt.energy_from_cell)
self.manager.add_score(opt.score_cell_eat)
shield.start_delay(opt.frames_to_eat_cell)
#player with cannon
if collide_mask(player, cannon):
#if in deactivated phase, try spending required energy to activate
if (cannon.get_state_number() == Cannon.DEACTIVATED
and self.manager.spend_energy(opt.cannon_energy_cost)):
cannon.start_standby()
#if in firing phase, kill player
if cannon.get_state_number() == Cannon.FIRING:
self.kill_player()
#if in returning phase, give energy and deactivate cannon
if cannon.get_state_number() == Cannon.RETURNING:
cannon.start_transition(Cannon.DEACTIVATED)
self.manager.give_energy(opt.energy_from_cannon)
#cannon with cell
#kill one cell and reverse cannon direction
#assuming this is only possible if cannon in firing state
if cannon.get_state_number() == Cannon.FIRING:
cannon_collides = spritecollide(cannon, shield, False,
collide_mask)
if len(cannon_collides) > 0:
cannon_collides[0].kill()
self.manager.add_score(opt.score_cell_shoot)
cannon.start_transition(Cannon.RETURNING)
#cannon with enemy base -- only if cannon in firing state
#give points corresponding to enemy state and end level
#if enemy base is in shooting state, player also gets a life
if cannon.get_state_number() == Cannon.FIRING and collide_mask(
cannon, enemy):
if enemy.get_state_number() == EnemyBase.MOVING:
self.manager.add_score(opt.score_mover_destroy)
elif enemy.get_state_number() == EnemyBase.SPINNING:
self.manager.add_score(opt.score_spinner_destroy)
elif enemy.get_state_number() == EnemyBase.SHOOTING:
self.manager.add_score(opt.score_shooter_destroy)
self.manager.give_life()
self.end_level()
#player's bullet with cell
#kill player bullet but remove cells in a cross pattern
#if somehow one bullet hits multiple cells one is arbitrarily selected
bc_collides = groupcollide(player_bullets, shield, True, False,
collide_mask)
for current_bullet in bc_collides.keys():
self.manager.add_score(opt.score_cell_shoot)
shield.remove_cross(bc_collides[current_bullet][0])
def find_centermost_cell(self, cells):
"""Given a list of Cell sprites,
returns the one whose rect.centery is closest to the player's rect.centery
Returns None if list is empty
"""
closest_cell = None
for current_cell in cells:
current_dist = abs(current_cell.rect.centery -
self.player.rect.centery)
if closest_cell is None or current_dist < closest_dist:
closest_cell = current_cell
closest_dist = current_dist
return closest_cell
def shoot(self):
"""If cannon can be fired, fires cannon.
Otherwise creates bullet moving from player's center along player's direction
as long as options.max_player_bullets won't be exeeded
"""
if collide_mask(self.player, self.ion_field):
return
if self.cannon.start_transition(Cannon.FIRING):
return
if len(self.player_bullets) < opt.max_player_bullets:
new_bullet = Bullet(opt.bullet_filename, opt.bullet_speed,
self.player.get_rect().center,
self.player.get_direction())
self.player_bullets.add(new_bullet)
def reset_positions(self):
"""Moves sprites to their initial locations:
player starts in left center facing south and with 0 energy
player bullets are removed
enemy bullet starts on enemy base
enemy base is in moving state
cannon is in deactivated state
Note: shield configuration is not reset
"""
self.player.rect.midleft = (20, int(opt.height / 2))
self.player.set_direction(vector.SOUTH)
self.player_bullets.empty()
self.enemy.resume_mover_state()
self.cannon.start_deactivated()
self.hbullet.rect.center = self.enemy.rect.center
def kill_player(self):
death_animation = DeathAnimation(self.manager, self.player,
(self.enemy, self.shield), self,
opt.death_animation_delay,
opt.death_animation_total_runtime)
self.manager.change_state(death_animation)
def end_level(self):
win_animation = WinAnimation(self.manager, self.player,
opt.win_animation_total_runtime,
opt.exp_field_args)
self.manager.change_state(win_animation)
class AlienFleet:
def __init__(self, session_stats, ship, player_bullets, alien_bullets,
on_clear_callback, on_kill_callback, on_player_collision_callback, on_bottom_callback):
self.session_stats = session_stats
self.ship = ship
self.player_bullets = player_bullets
self.alien_bullets = alien_bullets
self.on_clear = on_clear_callback
self.on_kill = on_kill_callback
self.on_player_collision = on_player_collision_callback
self.on_bottom = on_bottom_callback
self.aliens = Group()
self.ufos = Group()
self.explosions = Group()
self.create_new_fleet()
self.max_aliens = len(self.aliens)
self.next_ufo_appearance = random.uniform(config.ufo_min_delay, config.ufo_max_delay)
self.next_shot_timer = 1. / session_stats.fleet_shots_per_second
self.font = pygame.font.SysFont(None, 24)
# if this is the first level, hard-code the appearance of a UFO so it's clear that requirement was met
if self.session_stats.level == 0:
self.next_ufo_appearance = 5.0
def update(self, elapsed):
# Check if the fleet is at an edge, and then update the positions of all aliens in the fleet
self._check_fleet_edges()
self._check_ufo_offscreen()
self.aliens.update(elapsed)
self.ufos.update(elapsed)
self.explosions.update(elapsed)
# Look for alien-ship collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.on_player_collision()
# Look for aliens hitting the bottom of the screen
self._check_aliens_bottom()
# Look for player bullet->alien collisions
self._check_bullet_alien_collisions(self.player_bullets)
# Look for alien bullet->ship collisions
if pygame.sprite.spritecollideany(self.ship, self.alien_bullets):
self.on_player_collision()
# spawn new ufo, if needed
self.next_ufo_appearance -= elapsed
if self.next_ufo_appearance < 0:
self._spawn_ufo()
# is it time to fire another bullet?
self.next_shot_timer -= elapsed
self._update_shooting()
def draw(self, screen):
self.aliens.draw(screen)
self.ufos.draw(screen)
self.explosions.draw(screen)
def create_new_fleet(self):
"""Create a full fleet of aliens"""
# Create an alien and find the number of aliens in a row.
alien = Alien(self.session_stats, config.atlas.load_animation(self.session_stats.alien_stats[0].sprite_name))
number_aliens_x = self._get_number_aliens_x(alien.rect.width)
number_rows = self._get_number_rows(alien.rect.height)
self.aliens.empty()
self.ufos.empty()
self.explosions.empty()
self.alien_bullets.empty()
sounds.silence()
# Create the first row of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
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 += config.fleet_drop_speed
self.session_stats.fleet_direction *= -1
@staticmethod
def _get_number_aliens_x(alien_width):
"""Determine the number of aliens that fit in a row"""
available_space_x = config.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / alien_width)
return number_aliens_x
def _get_number_rows(self, alien_height):
"""Determine the number of rows of aliens that fit on the screen"""
available_space_y = (config.screen_height - alien_height - 8 * self.ship.rect.height)
number_rows = int(available_space_y / alien_height)
return number_rows
def _create_alien(self, alien_number, row_number):
"""Create an alien and place it in the row"""
num_types = len(config.alien_stats)
alien_stats = self.session_stats.alien_stats[alien_number % num_types]
alien = Alien(self.session_stats, config.atlas.load_animation(alien_stats.sprite_name))
alien_width = alien.rect.width
alien.rect.x = alien_width + alien_width * alien_number
alien.rect.y = alien.rect.height * 2 + alien.rect.height * row_number
alien.position = alien.rect.x
alien.alien_stats = alien_stats
self.aliens.add(alien)
def _create_alien_explosion(self, alien, as_points=False):
"""Create an alien explosion located where this alien is"""
if not as_points:
explosion_animation = config.atlas.load_animation(alien.alien_stats.sprite_name + "_explosion")
explosion = OneShotAnimation.from_animation(explosion_animation)
else:
score_str = "{:,}".format(alien.alien_stats.points)
surf = self.font.render(score_str, True, config.green_color)
explosion = OneShotAnimation(surf, 0.5)
# a little closure to automatically remove explosion when it's done running
def die_on_finish():
self.explosions.remove(explosion)
explosion.on_complete = die_on_finish
explosion.rect.center = alien.rect.center
self.explosions.add(explosion)
sounds.play("explosion1.wav")
def _check_aliens_bottom(self):
"""Check if any aliens have reached the bottom of the screen."""
for alien in self.aliens.sprites():
if alien.rect.bottom >= config.screen_height:
self.on_bottom()
break
def _check_bullet_alien_collisions(self, bullets):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided
collisions = pygame.sprite.groupcollide(bullets, self.aliens, True, True)
if collisions:
for aliens in collisions.values():
for an_alien in aliens:
self._create_alien_explosion(an_alien)
self.on_kill(an_alien)
# remove any bullets and UFOs that have collided
collisions = pygame.sprite.groupcollide(bullets, self.ufos, True, True)
if collisions:
for ufos in collisions.values():
for ufo in ufos:
self._create_alien_explosion(ufo, True)
self.on_kill(ufo)
if len(self.aliens) == 0 and len(self.ufos) == 0:
# If the entire fleet is destroyed, start a new level
self.on_clear()
self.create_new_fleet()
def _check_ufo_offscreen(self):
ufos = copy.copy(self.ufos.sprites())
for ufo in ufos:
# if ufo has moved off-screen, delete it without explosion or points
if ufo.speed < 0.0 and ufo.rect.right < 0:
self.ufos.remove(ufo)
elif ufo.speed > 0.0 and ufo.rect.left > config.screen_width:
self.ufos.remove(ufo)
if len(self.ufos) == 0:
sounds.fade_out("ufo", 250)
def _fire_alien_bullet(self, alien):
self.bullet_elapsed = 0.0
# create new animation for this bullet
bullet_anim = config.atlas.load_animation("alien_bullet")
# calculate bullet center position
# it should align with the BOTTOM of the alien
r = pygame.Rect(0, 0, bullet_anim.width, bullet_anim.height)
r.bottom = alien.rect.bottom
r.centerx = alien.rect.centerx
bullet = Bullet(self.session_stats.alien_bullet, r.center, bullet_anim)
self.alien_bullets.add(bullet)
sounds.play("laser2")
def _spawn_ufo(self):
self.next_ufo_appearance = random.uniform(config.ufo_min_delay, config.ufo_max_delay)
ufo = Ufo(self.session_stats, config.atlas.load_animation("ufo"))
rounded_score = int(round(random.randrange(self.session_stats.ufo_stats.points), -1))
ufo.alien_stats = config.AlienStats("ufo", rounded_score)
self.ufos.add(ufo)
if not sounds.is_playing("ufo"):
sounds.fade_in("ufo", 250, True)
def _update_shooting(self):
if self.next_shot_timer < 0.:
num_aliens_alive = len(self.aliens)
if num_aliens_alive == 0:
return
# calculate how long till next shot
delta = self.session_stats.fleet_max_shots_per_second - self.session_stats.fleet_shots_per_second
alive_ratio = num_aliens_alive / self.max_aliens
shots_per_second = (1. - alive_ratio) * delta + self.session_stats.fleet_shots_per_second
self.next_shot_timer = 1. / shots_per_second
# select an alien to fire this bullet
alien = random.choice(self.aliens.sprites())
self._fire_alien_bullet(alien)
@property
def alive_ratio(self):
return len(self.aliens) / self.max_aliens
class Talia:
#wypelnienie stosu kartami
def __init__(self, ekran, pula, tryb):
self.tryb = tryb
self.stos = Group()
self.ekran = ekran
self.pula = pula
self.wypelnij_talie()
def wypelnij_talie(self):
koniec = len(self.pula.zdjecia_otwartych)
if self.tryb == 1:
licznik = 15
else:
licznik = 27
for i in range(koniec):
if i != (koniec - 1):
nowa_karta = Karta(self.ekran, self.pula, licznik, False,
self.tryb)
self.stos.add(nowa_karta)
licznik += 1
else:
nowa_karta = Karta(self.ekran, self.pula, licznik, True,
self.tryb)
self.stos.add(nowa_karta)
#wydobycie ostatniego elementu w stosie
def znajdz_ostatni(self):
ostatni = None
for karta in self.stos.sprites():
ostatni = karta
return ostatni
def znajdz_przed_ostatni(self):
przed_ostatni = None
for karta in self.stos.sprites():
if not karta.widocznosc:
przed_ostatni = karta
return przed_ostatni
#sprawdzenie czy uzytkownik wcisnal karte jesli tak to ustawienie nowej na szczycie stosu
def sprawdz_czy_wcisnieto(self, event, strategie):
for karta in self.stos.sprites():
if not karta.widocznosc and karta.rect.collidepoint(
event.pos) and karta.rysuj:
ostatni = self.znajdz_ostatni()
self.stos.remove(ostatni)
ostatni = self.znajdz_ostatni()
ostatni.zmien_poz_stos()
ostatni.zmien_widocznosc()
strategie.mnoznik = 1
""" Warunek sprawdzajacy czy dlugosc stosu jest wieksza od 1 jesli tak
program szuka przed ostatniej karty w stosie i sprawia ze zostaje
ona wypisana na ekran w swoim stanie widocznosci """
if len(self.stos) > 1:
przed_ostatni = self.znajdz_przed_ostatni()
przed_ostatni.zmien_wyswietlanie()
if karta.hint:
karta.hint = False
return True
#usuniecie karty ze stosu
def usun_karte(self, karta):
self.stos.remove(karta)
#dodanie karty do stosu
def dodaj_karte(self, karta):
self.stos.add(karta)
#oproznienie talii i ponowne jej wypelnienie
def restart(self):
self.stos.empty()
self.wypelnij_talie()
class SpaceGame(Microgame):
def __init__(self):
Microgame.__init__(self)
# TODO: Initialization code here
self.count = 0
self.spaceship = Spaceship()
self.bg = Background()
self.planet = Planet()
self.monster = Group(Monster())
self.earth = Group(EarthExp())
self.background = Group(self.bg)
self.sprites = Group(self.planet, self.spaceship)
self.is_win = False
self.is_lose = False
def generate_asteroid(self):
if self.count == 10:
if randint(0,1) == 0:
self.sprites.add(Asteroid(-10, randint(0, locals.HEIGHT - 400), 1))
else:
self.sprites.add(Asteroid(locals.WIDTH + 10, randint(0, locals.HEIGHT - 400), -1))
self.count = 0
else:
self.count += 1
def start(self):
# TODO: Startup code here
music.load(join("games","space","music","space_song.ogg"))
music.play()
def stop(self):
# TODO: Clean-up code here
music.stop()
def update(self, events):
# TODO: Update code here
self.background.update()
self.sprites.update()
#Make asteroids
self.generate_asteroid()
#Check if spaceship hits sides of screen
x_ship_left, _ = self.spaceship.rect.bottomleft
x_ship_right, _ = self.spaceship.rect.bottomright
if x_ship_left <= 0:
self.spaceship.x_velocity = 0
elif x_ship_right >= locals.WIDTH - 14:
self.spaceship.x_velocity = 0
#Check if spaceship hits top/bottom of screen sectioned to movement
_, y_ship_top = self.spaceship.rect.topleft
_, y_ship_bottom = self.spaceship.rect.bottomleft
if y_ship_top <= locals.HEIGHT - 300:
self.spaceship.y_velocity = 0
elif y_ship_bottom >= locals.HEIGHT - 20:
self.spaceship.y_velocity = 0
#Process user input
for event in events:
if event.type == KEYDOWN and event.key == K_LEFT:
if x_ship_left > 0:
self.spaceship.x_velocity -= VELOCITY_INC
elif event.type == KEYUP and event.key == K_LEFT:
self.spaceship.x_velocity = 0
elif event.type == KEYDOWN and event.key == K_RIGHT:
if x_ship_right < locals.WIDTH - 14:
self.spaceship.x_velocity += VELOCITY_INC
elif event.type == KEYUP and event.key == K_RIGHT:
self.spaceship.x_velocity = 0
elif event.type == KEYDOWN and event.key == K_UP:
if y_ship_top > locals.HEIGHT - 300:
self.spaceship.y_velocity -= VELOCITY_INC
elif event.type == KEYUP and event.key == K_UP:
self.spaceship.y_velocity = 0
elif event.type == KEYDOWN and event.key == K_DOWN:
if y_ship_bottom < locals.HEIGHT - 20:
self.spaceship.y_velocity += VELOCITY_INC
elif event.type == KEYUP and event.key == K_DOWN:
self.spaceship.y_velocity = 0
#music.load(join("games","space","music","Powerup7.wav"))
#music.play()
#Make win when spaceship hits planet
if self.planet.rect.colliderect(self.spaceship.rect):
sound_planet = pygame.mixer.Sound(join("games","space","music","Powerup.wav"))
sound_planet.play()
self.is_win = True
for each in self.sprites.sprites():
if isinstance(each, Asteroid):
if each.rect.colliderect(self.spaceship.rect):
sound_asteroid = pygame.mixer.Sound(join("games","space","music","Explosion.wav"))
sound_asteroid.play()
self.is_lose = True
#Creates win scree
if self.is_win:
self.sprites.empty()
self.background.empty()
self.sprites.add(Monster())
#Creates lose screen
elif self.is_lose:
self.sprites.empty()
self.background.empty()
self.sprites.add(EarthExp())
def render(self, surface):
# TODO: Rendering code here
surface.fill(Color(0, 0, 0))
self.background.draw(surface)
self.sprites.draw(surface)
def get_timelimit(self):
# TODO: Return the time limit of this game (in seconds, 0 <= s <= 15)
#raise NotImplementedError("get_timelimit")
return 15
class Bullets:
"""A class to handle all bullets."""
def __init__(self, ai_settings, screen, sprite_sheet, stats, sb, ship,
fleet, barriers, explosions, sounds):
"""Initialize instance attributes."""
self.ai_settings = ai_settings
self.screen = screen
self.sprite_sheet = sprite_sheet
self.stats = stats
self.sb = sb
self.ship = ship
self.fleet = fleet
self.barriers = barriers
self.explosions = explosions
self.sounds = sounds
self.bullets = Group()
self.alien_bullets = Group()
self.last_alien_amount = 55
# Interactions Needed
# ship_hit()
# create_barriers
def fire_bullet(self):
"""Fire a bullet if limit not reached yet."""
bullet_offset = 0
# Create a new bullet and add it to the bullets group.
if len(self.bullets) < self.ai_settings.bullets_allowed:
self.sounds.ship_bullet_sound.play()
for _ in range(3):
new_bullet = Bullet(ai_settings=self.ai_settings,
screen=self.screen,
ship=self.ship,
bullet_y=bullet_offset)
self.bullets.add(new_bullet)
bullet_offset += 55
def alien_shoot(self, alien):
"""Create a bullet from an alien."""
self.sounds.alien_bullet_sound.play()
new_bullet = AlienBullet(screen=self.screen,
sprite_sheet=self.sprite_sheet,
x=alien.rect.x,
y=alien.rect.y,
version=random.randint(0, 1))
self.alien_bullets.add(new_bullet)
def update_bullets(self, display):
"""Update position of bullets and get rid of old bullets."""
# Update bullet positions.
self.bullets.update()
self.alien_bullets.update()
# Get rid of bullets that have disappeared.
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
for bullet in self.alien_bullets.copy():
if bullet.rect.top >= self.screen.get_rect().bottom:
self.alien_bullets.remove(bullet)
self.check_bullet_alien_collisions(display=display)
self.check_bullet_ship_collisions(display=display)
self.check_bullet_barrier_collisions(display=display)
def check_bullet_alien_collisions(self, display):
"""Respond to bullet-alien collisions."""
# Remove any bullets, aliens, and ufos that have collided.
collisions = pygame.sprite.groupcollide(self.bullets,
self.fleet.aliens, True, True)
ufo_collisions = pygame.sprite.groupcollide(self.bullets,
self.fleet.ufos, True,
True)
if collisions or ufo_collisions:
for aliens in collisions.values():
for alien in aliens:
self.sounds.alien_destroy_sound.play()
explosion = Explosion(screen=self.screen,
sprite_sheet=self.sprite_sheet,
rect=alien.rect)
explosion.blitme()
self.explosions.add(explosion)
self.stats.score += (alien.points *
self.ai_settings.score_scale)
self.sb.prep_score()
for ufos in ufo_collisions.values():
for ufo in ufos:
self.sounds.ufo_sound.stop()
self.sounds.alien_destroy_sound.play()
ufo_points = random.randrange(40, 200, 10)
display.draw_ufo_points(ufo_points, ufo)
self.stats.score += ufo_points
self.sb.prep_score()
self.sb.check_high_score()
if (len(self.fleet.aliens) == 40 or len(self.fleet.aliens) == 25 or len(self.fleet.aliens) == 10)\
and self.last_alien_amount != len(self.fleet.aliens):
# Speed up tempo of background music here
self.sounds.background_music.stop()
self.sounds.speed_up_bg_music()
self.last_alien_amount = len(self.fleet.aliens)
self.sounds.background_music.play(-1)
print(self.sounds.background_music_counter)
if len(self.fleet.aliens) == 0 and len(self.fleet.ufos) == 0:
# If the entire fleet is destroyed, increase the difficulty and start a new level.
self.bullets.empty()
self.ai_settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
self.fleet.create_fleet()
self.sounds.background_music.stop()
self.sounds.background_music = self.sounds.background_track[0]
self.sounds.background_music.play(-1)
self.sounds.background_music_counter = 1
display.create_barriers()
def check_bullet_ship_collisions(self, display):
"""Respond to bullet-ship collisions."""
collisions = pygame.sprite.spritecollide(self.ship, self.alien_bullets,
True)
if collisions:
self.ship.ship_hit(bullets=self, fleet=self.fleet, display=display)
def check_bullet_barrier_collisions(self, display):
"""Respond to bullet-barrier collisions."""
for barrier in display.barriers:
pygame.sprite.groupcollide(self.bullets, barrier.barrier, True,
True)
pygame.sprite.groupcollide(self.alien_bullets, barrier.barrier,
True, True)
) # добавляем объект в список сообщения, который нужен для передачи в шифрующую функцию
messx += PL_W
# обновляем все объекты группы сообщения (вызываем метод update)
for i in message_group:
i.update()
for i in button_group: # перебираем объекты группы кнопок управления
i.update() # вызывем для каждого объекта метод update
if i.onClick(
mouse_click): # проверяем было ли нажатие по данной кнопке
if i.text == 'Зашифровать': # если было нажатие и текст кнопки = Зашифровать
message_list = encode() # то вызываем функцию шифрования
if i.text == 'Стереть': # если текст кнопки = Стереть
# очищаем все группы кроме групп алфавита и кнопок управления
message_group.empty()
messx = 150 # задаем начальное положение отображения сообщения
encode_message_group.empty()
message_list = [] # обнуляем список объектов для дешифрования
decode_message.empty()
if i.text == 'Дешифровать': # если текст кнопки = Дешифровать
decode(message_list) # вызываем функцию дешифрования
if i.text == 'Показать коды': # если текст = Показать коды
i.text = i.alt_text # меняем текст данной кнопки на альтернативный
show_codes(
[message_group, encode_message_group, decode_message]
) # вызываем функцию show_codes передавая ей все группы кнопок коды которых нужно показать
elif i.text == 'Показать текст': # если текст кнопки = Показать текст
i.text = 'Показать коды' # меняем основной текст на Показать коды
show_text(
[message_group, encode_message_group, decode_message]
class level1():
def __init__(self,
screen,
levelpath="levels/1",
levelnum=1,
highscore=0,
joystick=False):
self.levelpath = levelpath
self.joystick = joystick
if self.joystick:
self.joy1 = pygame.joystick.Joystick(0)
self.joy1.init()
self.joy2 = pygame.joystick.Joystick(1)
self.joy2.init()
print("got joysticks in level")
pygame.mouse.set_visible(False)
self.screen = screen
self.player = xanplayer.Ship(screen)
self.speed = 1
self.lives = 3
self.highscore = int(highscore)
self.levelnum = levelnum
self.quit = False
self.lost = False
self.goodshots = Group()
self.badshots = Group()
self.enemies = Group()
self.screen_rect = self.screen.get_rect()
#print("top", self.screen_rect.top)
self.bg = pygame.image.load("xanfiles/space1.gif")
self.lifeimg = pygame.image.load("xanfiles/playershipsmall.png")
self.music = pygame.mixer.Sound("xanfiles/SpaceFlight.wav")
with open(levelpath + "/enemies.txt") as obj:
self.enemymap = json.load(obj)
self.enemycounter = 0
self.enemypos = 0
self.won = False
self.blue = pygame.color.Color("#00bcff")
self.dblue = pygame.color.Color("#0000ff")
self.black = pygame.color.Color("#000000")
self.score = 0
def init(self):
#self.bg_color = (230, 230, 230)
#self.screen.fill(self.bg_color)
self.pic_rect = self.bg.get_rect()
self.liferect = self.lifeimg.get_rect()
self.liferect.top = self.screen_rect.top
self.screen.blit(self.bg, self.pic_rect)
font = pygame.font.Font('xanfiles/ARDESTINE.ttf', 50)
words = font.render('Xandaar', True, self.blue)
ywr = words.get_rect()
ywr.bottom = self.screen_rect.bottom
self.screen.blit(words, ywr)
pygame.display.flip()
self.music.play(-1)
#self.init_menu()
def init_menu(self):
nada = lambda: print("asdfad", sep=" ")
#self.menu=pygameMenu.Menu(self.screen, 1000, 600, "xanfiles/ARDESTINE.ttf", "Game Paused", None, dopause=True)
#self.menu.add_option('Exit', PYGAME_MENU_CLOSE)
#self.menu.disable()
def drawbar(self):
pygame.draw.rect(self.screen, self.black, [
self.screen_rect.right - 200, self.screen_rect.bottom - 50, 200, 50
])
font = pygame.font.Font('xanfiles/ARDESTINE.ttf', 20)
score = font.render("Score: " + "{:,}".format(self.score), False,
self.blue, self.black)
ywr = score.get_rect()
ywr.bottom = self.screen_rect.bottom - 25
ywr.right = self.screen_rect.right
self.screen.blit(score, ywr)
hscore = font.render("High Score: " + "{:,}".format(self.highscore),
False, self.blue, self.black)
ywr = hscore.get_rect()
ywr.bottom = self.screen_rect.bottom
ywr.right = self.screen_rect.right
self.screen.blit(hscore, ywr)
level = font.render("Level: " + str(self.levelnum), True, self.blue,
self.black)
ywr = level.get_rect()
ywr.bottom = self.screen_rect.bottom
ywr.centerx = self.screen_rect.centerx
self.screen.blit(level, ywr)
pygame.display.flip()
def pauseloop(self):
done = False
pos = list(self.screen_rect.center)
pos.extend([50, 100])
mpos = (0, 0)
while not done:
pygame.draw.rect(self.screen, self.dblue, pos)
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
mpos = pygame.mouse.get_pos()
if event.type == pygame.QUIT:
done = True
self.quit = True
if pos[0] <= mpos[0] <= pos[0] + pos[2] and pos[1] <= mpos[
1] <= pos[1] + pos[3]:
done = True
pygame.display.flip()
def events(self):
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
self.quit = True
#print("quit")
if self.joystick == False:
if event.type == pygame.KEYDOWN:
checkkeydown(event, self.player, self.goodshots,
self.screen)
elif event.type == pygame.KEYUP:
checkkeyup(event, self.player, self.pauseloop)
#else:
# checkjoyevents()
if self.joystick:
event = ""
do = checkjoystickevents(event, self.player, self.goodshots,
self.screen, self.joy1, self.joy2)
if do == "Quit":
self.quit = True
#self.menu.mainloop(events)
if self.enemycounter >= 100:
#print("updating enemies")
self.enemycounter = 0
self.enemypos += 1
self.update_enemies()
else:
#print(self.enemycounter)
self.enemycounter += 1
if self.lives == 0:
self.lost = True
if self.score > self.highscore:
self.highscore = self.score
#self.menu.mainloop(events)
def draw(self):
self.drawbar()
self.player.update()
self.enemies.update()
self.goodshots.update()
self.badshots.update()
self.score += update_bullets(self.goodshots, self.enemies,
self.screen_rect)
if pygame.sprite.spritecollideany(self.player, self.enemies):
self.lives -= 1
#self.enemies.empty()
for alien in self.enemies:
if alien.rect.x <= 100:
alien.kill()
self.badshots.empty()
time.sleep(0.5)
if pygame.sprite.spritecollideany(self.player, self.badshots):
self.lives -= 1
#self.enemies.empty()
self.badshots.empty()
time.sleep(0.5)
#print(len(self.goodshots))
#self.screen.fill(self.bg_color)
self.screen.blit(self.bg, self.pic_rect)
for i in range(self.lives):
#print("making lives at", 0 + (20*i), 0)
self.screen.blit(self.lifeimg, ((20 * i), 0))
self.player.blitme()
for i in self.enemies:
i.blitme()
try:
#if True:
for b in i.fire():
self.badshots.add(b)
except:
#else:
pass
for bullet in self.goodshots.sprites():
bullet.draw_bullet()
for bullet in self.badshots.sprites():
bullet.draw_bullet()
pygame.display.flip()
def end(self):
font = pygame.font.Font('xanfiles/ARDESTINE.ttf', 20)
level = font.render("Level " + str(self.levelnum) + " Completed!",
False, self.blue, self.black)
ywr = level.get_rect()
ywr.center = self.screen_rect.center
self.screen.blit(level, ywr)
pygame.display.flip()
pygame.mixer.stop()
time.sleep(3)
def update_enemies(self):
self.enemies, self.won = update_enemies(self.enemymap, self.enemypos,
self.enemies, self.screen,
self.player)
class Game:
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(
(Settings.screen_width, Settings.screen_height))
pygame.display.set_caption("Chen Invaders")
self.stats = GameStats()
# self.sb = Scoreboard(self.screen, self.stats)
self.scoreboard = Scoreboard(self.screen)
# Make a ship, a group of projectiles, and a group of aliens.
self.allied_projectiles = ProjectileGroup(self.screen)
self.enemy_projectiles = ProjectileGroup(self.screen)
self.neutral_projectiles = ProjectileGroup(self.screen)
self.drop_group = DropGroup(self.screen)
self.explosion_group = Group()
self.player = Player(self.screen)
self.enemies = EnemyGroup(self.screen)
self.collision_manager = CollisionManager(self)
self.graveyard = Graveyard(self)
self.level_generator = LevelGenerator(self)
self.input_handler = InputHandler(self)
self.starting_screen = StartingScreen(self.screen)
self.hud = HUD(self)
self.painter = Painter(self)
self.ai = AI(self)
self.game_state = GameState.game_inactive
pygame.mixer.music.load("sound/start.mp3")
pygame.mixer.music.play()
self.clock = pygame.time.Clock()
self.time_until_next_horde = 0
pygame.mixer.init()
def run(self):
while True:
self.input_handler.parse_user_input()
self.update()
self.painter.paint()
def update(self):
if self.game_state == GameState.game_active:
self.game_activate_update()
elif self.game_state == GameState.game_level_passed:
self.game_level_passed_update()
def game_activate_update(self):
self.player.update()
self.ai.update_aliens()
self.enemies.update()
self.drop_group.update()
self.allied_projectiles.update()
self.enemy_projectiles.update()
self.neutral_projectiles.update()
self.collision_manager.check_collisions()
self.graveyard.check_deaths()
self.explosion_group.update()
def game_level_passed_update(self):
self.player.update()
self.enemies.update()
self.drop_group.update()
self.allied_projectiles.update()
self.enemy_projectiles.update()
self.neutral_projectiles.update()
self.collision_manager.check_collisions()
self.explosion_group.update()
self.level_ended()
def begin_game(self):
# Hide the mouse cursor.
self.game_state = GameState.game_active
pygame.mouse.set_visible(False)
pygame.mixer.music.load("sound/BGM.mp3")
pygame.mixer.music.play()
self.begin_level()
def begin_level(self):
self.time_until_next_horde = 0
# Empty the list of aliens and bullets.
self.enemies.empty()
self.allied_projectiles.empty()
self.enemy_projectiles.empty()
self.neutral_projectiles.empty()
self.drop_group.empty()
# Create a new fleet and center the ship.
self.level_generator.create_fleet()
def level_ended(self):
# TODO fazer animacaozinha que o alien desce do topo ate o meio
tick = float(self.clock.tick())
self.time_until_next_horde += tick
if self.time_until_next_horde > Settings.next_level_delay:
self.game_state = GameState.game_active
self.begin_level()
def end_game(self):
self.game_state = GameState.game_inactive
self.scoreboard.reset_score()
self.player.reset_health()
self.player.reset_position()
self.level_generator.nivel = 0
self.enemies.empty()
self.allied_projectiles.empty()
self.enemy_projectiles.empty()
self.neutral_projectiles.empty()
self.drop_group.empty()
self.explosion_group.empty()
pygame.mixer.music.load("sound/start.mp3")
pygame.mixer.music.play()
pygame.mouse.set_visible(True)
def run_game():
global ch, dobollet, db, wea, t
pygame.init()
pygame.mixer.init()
shoot = mixer.Sound("C:\windows\media\Ring02.wav")
music = mixer.Sound("sounds/Windows Critical Stop.wav")
image = pygame.image.load('bg.gif')
turn = 0
ch = 10
fg = 1
pfg = 1
joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
print(joysticks.pop(1))
for joystick in joysticks:
joystick.init()
i = 0
j = False
sit = False
sco = 0
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alien Invasion')
ship = Ship(ai_settings, screen)
bullets = Group()
ships = Group()
blocks = Group()
aliens = Group()
l = 0
r = 0
godown = 0
sb = Scoreboard(ai_settings, screen, 0, sco)
alies = Group()
buttons = Group()
yu = False
#rint(ship.y)iii
alienbullets = Group()
ert = 0
tr = [
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 2, 0, 0, 0, 0, 1, 1, 1, 1, 0,
0, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 2, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 2
]
sty = Group()
uii = 0
do_liberint(pygame, Block, blocks, ai_settings, screen, 'liberint.txt',
Alien, aliens)
upup = 0
ship2 = Ship(ai_settings, screen)
for alien in aliens.sprites():
alien.image = pygame.image.load('bomb.gif')
poweraps = Group()
aiens = Group()
ant = Ant_men(ai_settings, screen, ship)
ships.add(ship)
ships.add(ship2)
shoot.play(-1)
time = 0
un = 0
while True:
if r == 0:
#ship.imageship.image = pygame.image.load('SCrightup.gif')
ship.blitme()
#pygame.display.flip()
for alien in blocks.sprites():
alien.x -= 1
alien.rect.x = alien.x
#pygame.display.flip()
#pygame.display.flip()
#pygame.display.flip()
#ship.image = pygame.image.load('SCright.gif')
ship.blitme()
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if l == 0:
# ship.image = pygame.image.load('SCleftup.gif')
#pygame.display.flip()
for alien in blocks.sprites():
alien.x += 1
alien.rect.x = alien.x
#pygame.display.flip()
#pygame.display.flip()
#pygame.display.flip()
#ship.blitme()
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if r == 0:
ant.x -= 1
ant.rect.x = ant.x
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x += 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x += 1
# alien.rect.x = alien.x
if l == 0:
ant.x += 1
ant.rect.x = ant.x # if pygame.sprite.spritecollideany(ship,blocks):
# for alien in poweraps.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
# for alien in blocks.sprites():
# alien.x -= 1
# alien.rect.x = alien.x
for event in pygame.event.get():
#for event in pygame.event.get():
# # if event.type == pygame.KEYDOWN:
# if event.key == pygame.K_1:
# first = randint(0,220)
# second = randint(0,220)
# three = randint(0,220)
# ai_settings.bg_color = (first,second,three)
# if event.key == pygame.K_b:
# sys.exit()
# if event.key == pygame.K_RIGHT:
# #ship.movin_right = True
# cr = 0
# t = 2
# if event.key == pygame.K_LEFT:
# #ship.movin_left = True
# cl = 0
# t = 3
# if event.key == pygame.K_r:
# #ship.movin_left = True
# if len(bullets) <= bulets:
# new_bullet = Bullet(ai_settings,screen,ship,aliens,bullets,0)
# bullets.add(new_bullet)
# if event.key == pygame.K_UP:
# cu = 0
# t = 0
if event.type == pygame.MOUSEBUTTONDOWN:
xy, yx = pygame.mouse.get_pos()
blok = Block(ai_settings, screen, 'fkdf')
blok.rect.x, blok.rect.y = xy, yx
blok.x, blok.y = xy, yx
blocks.add(blok)
if event.type == pygame.JOYAXISMOTION:
buttons = joystick.get_numaxes()
for i in range(buttons):
but = joystick.get_axis(0)
if but < -.5:
ship.x -= 1
ship.rect.x = ship.x
t = 3
but = joystick.get_axis(0)
if but > .5:
ship.x += 1
ship.rect.x = ship.x
t = 2
but = joystick.get_axis(1)
if but < -.5:
ship.y -= 1
ship.rect.y = ship.y
if but > .5:
ship.y += 1
ship.rect.y = ship.y
# but = joystick.get_axis(1)
# if but < -.5:
# ship.y -= 1
# ship.rect.y = ship.y
# if pygame.sprite.spritecollideany(ship,blocks):
# ship.y += fuster
# ship.rect.y = ship.y
# t = 0
# but = joystick.get_axis(1)
# if but > .5:
# ship.y += 1
# ship.rect.y = ship.y
# if pygame.sprite.spritecollideany(ship,blocks):
# ship.y -= fuster
# ship.rect.y = ship.y
# t = 1
buttons = joystick.get_numhats()
for i in range(buttons):
but = joystick.get_hat(i)
if but == (-1, 0):
ship.rect.x -= 1
but = joystick.get_hat(i)
if but == (1, 0):
ship.rect.x += 1
but = joystick.get_hat(i)
if but == (0, -1):
ship.rect.y -= 1
but = joystick.get_hat(i)
if but == (0, 1):
ship.rect.y += 1
but = joystick.get_hat(i)
print(but)
#if but == (0,1):
# j = False
# pfg *=-1
# j = True
# but = joystick.get_hat(i)
if event.type == pygame.JOYBUTTONDOWN:
buttons = joystick.get_numbuttons()
for button in range(buttons):
# # print(button)
# #pass
# # if button == (0,0):
# # music.play()
# # new_bullet = Bullet(ai_settings,screen,ship,aliens,bullets,alien,t)
# # bullets.add(new_bullet)
but = joystick.get_button(0)
if but:
j = False
pfg *= -1
j = True
but = joystick.get_button(2)
if but:
if upup == 0:
upup = 1
break
if upup == 1:
upup = 0
break
#print(but)
# if but == 2:
# j = False
# pfg *=-1
# j = True
# but = joystick.get_button(button)
# if but == 1:
# upup = 1
elif event.type == pygame.JOYBUTTONUP:
#buttons = joystick.get_numbuttons()
buttons = joystick.get_numbuttons()
for button in range(buttons):
# # print(button)
# #pass
# # if button == (0,0):
# # music.play()
# # new_bullet = Bullet(ai_settings,screen,ship,aliens,bullets,alien,t)
# # bullets.add(new_bullet)
but = joystick.get_button(2)
if but:
upup = 0
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
cl2 = 0
cr2 = 1
cu2 = 1
cd2 = 1
t2 = 3
if event.key == pygame.K_RIGHT:
cl2 = 1
cr2 = 0
cu2 = 1
cd2 = 1
t2 = 2
#but = joystick.get_hat(i)
if event.key == pygame.K_DOWN:
cl2 = 1
cr2 = 1
cu2 = 1
cd2 = 0
t2 = 1
#but = joystick.get_hat(i)
if event.key == pygame.K_UP:
cl2 = 1
cr2 = 1
cu2 = 0
cd2 = 1
t2 = 0
if event.key == pygame.K_v:
new_bullet = Bullet(ai_settings, screen, ship2, aliens,
bullets, alien, t2)
bullets.add(new_bullet)
# elif event.type == pygame.KEYUP:
# if event.key == pygame.K_RIGHT:
# ship.movin_right = False
# cr = 1
# if event.key == pygame.K_LEFT:
# ship.movin_left = False
# cl = 1
# if event.key == pygame.K_UP:
# cu = 1
# if event.key == pygame.K_DOWN:
# cd = 1
# if event.key == pygame.K_2:
# ship.image = pygame.image.load(random.choice(images))
# if event.key == pygame.K_DOWN:
# ship.movin_down = False
# #276
#276
ship.update(blocks, ship)
bullets.update(bullets, aliens)
collisions = pygame.sprite.groupcollide(ships, aliens, False, True)
#print('you lose')
#break
ship.blitme()
# if pygame.sprite.spritecollideany(ship,blocks):
# for alien in blocks.sprites():
# alien.y += 1
# alien.rect.y = alien.y
# ant.y += 1
# ant.rect.y = ant.y
# godown = 0
# pygame.display.flip()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0 or bullet.rect.bottom >= 900 or bullet.rect.centerx <= 0 or bullet.rect.centerx >= 1000:
bullets.remove(bullet)
screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.copy():
# if bullet.rect.bottom >= 900:
# bullets.remove(bul
# screen.fill(ai_settings.bg_color)
# for bullet in alienbullets.sprites():
# bullet.draw_bullet()
# first = randint(0,200)
# second = randint(0,200)
# three = randint(0,200)
# ai_settings.bullet_color = (first,second,three)
# collisins = pygame.sprite.groupcollide(blocks,bullets,True,True)
collisions = pygame.sprite.groupcollide(ships, poweraps, False,
True)
if len(aliens) <= 0:
print('you win')
break
# for alien in aliens.sprites():
# if pygame.sprite.spritecollideany(alien,blocks):
# alien.duraction *= -1
for bullet in bullets.sprites():
bullet.draw_bullet()
collisions = pygame.sprite.groupcollide(
bullets, aliens, True, True)
if collisions:
moneys += 1
collisions = pygame.sprite.groupcollide(
bullets, blocks, True, False)
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
bullets.update(bullets, aliens)
ship.blitme()
#chekupdown_fleet_edges(ai_settings,aliens)
#alien.blitme()
bullets.draw(screen)
sb.show_score()
alienbullets.update(bullets, aliens)
collisions = pygame.sprite.groupcollide(ships, aliens, False, True)
aliens.draw(screen)
#if un == 0:
blocks.draw(screen)
blocks.update()
if pygame.sprite.spritecollideany(ant, ships):
if pfg == -1:
g = 1
bullets.empty()
ch -= 1
if ch <= 0:
ant.image = pygame.image.load('bowserflat.gif')
un = 1
# print('you win')
# break
j = False
pfg *= -1
j = True
else:
if un == 0:
print('you lose')
sys.exit()
if pygame.sprite.spritecollideany(ant, bullets):
ch -= 1
bullets.empty()
if ch <= 0:
print('you win')
break
bullets.update(0, 0)
bullets.draw(screen)
ship2.blitme()
#if bezero == 34:
#bezero = 0
#sb.show_score()
#poweraps.draw(screen)
#pygame.display.update()
#screen.blit(image,(0,0))
pygame.display.flip()
class Game:
"""
游戏的主类，包含运行中的几乎所有信息，负责处理所有游戏功能
"""
# 类型提示，用于编译器自动补全和消除warning
canvas: pygame.Surface
screen: pygame.Surface
player: Player
enemies: Group
bullets_p: Group
bullets_e: Group
viewport: pygame.Rect
clock: pygame.time.Clock
joystick: pygame.joystick.Joystick
room: Room
debug: bool
game_status: bool
play_button: Button #关于游戏活动状态与否
def __init__(self):
pygame.event.set_allowed(setting.event_allowed)
self.setup()
self.done = False
self.game_status = False #初始时游戏状态为False
def setup(self):
self.canvas = pygame.Surface(setting.room_size)
self.screen = pygame.display.set_mode(setting.screen_resolution)
pygame.display.set_caption(setting.caption)
self.debug = setting.debug_default
self.clock = pygame.time.Clock()
if pygame.joystick.get_count() > 0:
self.joystick = pygame.joystick.Joystick(0)
self.joystick.init()
self.room = Room()
self.viewport = pygame.rect.Rect(0, 0, *setting.screen_resolution)
self.viewport.center = self.room.rect.center
self.setup_entities()
"""
按钮的设置
"""
self.play_button = Button(self.screen, "Play")
def setup_entities(self):
self.player = Player(image_dict['player'])
screen_rect = self.canvas.get_rect()
self.player.x = screen_rect.centerx
self.player.y = screen_rect.centery
self.player.viewport = self.viewport # 感觉这样搞破坏了封装性似乎有点不妥？
self.enemies = Group()
"""所有敌人的群组"""
self.bullets_p = Group()
"""玩家射出的子弹"""
self.bullets_e = Group()
"""敌人射出的子弹"""
# 注册room内的这些东西，这么写感觉很抠脚，有没有改进方法呢？
self.room.setup(self.enemies, self.bullets_p, self.bullets_e,
self.player)
self.room.generate(self.enemies)
def handle_events(self):
"""
处理所有事件
:return:
"""
for event in pygame.event.get():
if not self.game_status:
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
self.handle_check_play_button(mouse_x, mouse_y)
elif event.type == pygame.QUIT:
self.done = True
else:
continue
if event.type == pygame.KEYDOWN:
self.handle_keydown_events(event)
elif event.type == pygame.KEYUP:
self.handle_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
self.player.is_fire = True
self.player.fire_control = c.CONTROL_MOUSE
elif event.type == pygame.MOUSEBUTTONUP:
self.player.is_fire = False
elif event.type == pygame.QUIT:
self.done = True
elif event.type == pygame.JOYAXISMOTION:
self.handle_joy_axis_events()
def handle_check_play_button(self, mouse_x, mouse_y):
"""
检查鼠标按键是否点击了botton
"""
if self.play_button.rect.collidepoint(mouse_x, mouse_y):
self.game_status = True
if self.game_status:
self.game_restart()
def handle_joy_axis_events(self):
"""
这里有一个问题：手柄和键盘同时操作时，
可能会出现不受控制状态，只需把手柄摇杆摇到中间即可解决，更改代码不好处理。
improve:这里应该可以分离处理的，但是我不知道怎么改，（可能通过event拿信息？）
"""
move_x = self.joystick.get_axis(setting.joystick_axis_move_x)
move_y = self.joystick.get_axis(setting.joystick_axis_move_y)
fire_x = self.joystick.get_axis(setting.joystick_axis_fire_x)
fire_y = self.joystick.get_axis(setting.joystick_axis_fire_y)
if abs(move_x) >= setting.joystick_min_motion:
self.player.x_vel = setting.player_speed * move_x
else:
self.player.x_vel = 0.0
if abs(move_y) >= setting.joystick_min_motion:
self.player.y_vel = setting.player_speed * move_y
else:
self.player.y_vel = 0.0
if abs(fire_x) >= setting.joystick_min_motion or abs(
fire_y) >= setting.joystick_min_motion:
self.player.is_fire = True
self.player.fire_control = c.CONTROL_JOYSTICK
self.player.fire_dir = atan2(fire_y, fire_x)
else:
self.player.is_fire = False
def handle_keydown_events(self, event: pygame.event.Event):
keymap = setting.keymap
if event.key in keymap[c.CONTROL_UP]:
self.player.y_vel -= setting.player_speed
elif event.key in keymap[c.CONTROL_DOWN]:
self.player.y_vel += setting.player_speed
elif event.key in keymap[c.CONTROL_LEFT]:
self.player.x_vel -= setting.player_speed
elif event.key in keymap[c.CONTROL_RIGHT]:
self.player.x_vel += setting.player_speed
elif event.key in keymap[c.CONTROL_FIRE]:
self.player.is_fire = True
self.player.fire_control = c.CONTROL_KEYBOARD
elif event.key in keymap[c.CONTROL_DEBUG]:
self.debug = not self.debug
def handle_keyup_events(self, event: pygame.event.Event):
keymap = setting.keymap
if event.key in keymap[c.CONTROL_UP]:
self.player.y_vel += setting.player_speed
elif event.key in keymap[c.CONTROL_DOWN]:
self.player.y_vel -= setting.player_speed
elif event.key in keymap[c.CONTROL_LEFT]:
self.player.x_vel += setting.player_speed
elif event.key in keymap[c.CONTROL_RIGHT]:
self.player.x_vel -= setting.player_speed
elif event.key in keymap[c.CONTROL_FIRE]:
self.player.is_fire = False
def check_collision_be(self):
"""
检测子弹与敌人之间的碰撞，并处理这些碰撞
be:bullet and enemy
:return:
"""
collision = pygame.sprite.groupcollide(self.enemies, self.bullets_p,
False, True)
for enemy, bullets in collision.items():
for bullet in bullets:
enemy.hp -= bullet.damage
if enemy.hp <= 0:
enemy.kill() # kill函数会把它从所有群组里移除（pygame提供）
def check_collision_bp(self):
"""
检测子弹与玩家之间的碰撞，并处理这些碰撞
bp:bullet and player
:return:
"""
collision = pygame.sprite.spritecollide(self.player, self.bullets_e,
True)
for bullet in collision:
self.player.hp -= bullet.damage
if self.player.hp <= 0:
self.game_status = False
pass # 先占个坑，以后再写
def check_everything(self):
if self.player.is_fire:
self.player.fire(self.bullets_p)
self.check_collision_be()
self.check_collision_bp()
self.scroll_screen()
def scroll_screen(self):
"""
当玩家处于屏幕边缘时滚动屏幕
improve:这几段代码有重复的地方（编译器提示），但是我不知道怎么合并起来
:return:
"""
dx_l = self.viewport.left + setting.scroll_dis_x - self.player.rect.left
"""视点应向左移动的距离，下面的三段处理其他方向的代码逻辑和这个是一样的"""
if dx_l > 0:
self.viewport.left = max(0, self.viewport.left -
dx_l) # left必须大于0，否则就看到外面的黑框了
dx_r = self.player.rect.right + setting.scroll_dis_x - self.viewport.right
if dx_r > 0:
self.viewport.right = min(self.room.rect.right,
self.viewport.right + dx_r)
dy_u = self.viewport.top + setting.scroll_dis_y - self.player.rect.top
if dy_u > 0:
self.viewport.top = max(0, self.viewport.top - dy_u)
dy_d = self.player.rect.bottom + setting.scroll_dis_y - self.viewport.bottom
if dy_d > 0:
self.viewport.bottom = min(self.room.rect.bottom,
self.viewport.bottom + dy_d)
def remove_outbound_bullets(self):
for bullets in (self.bullets_p, self.bullets_e):
for bullet in bullets:
if not self.room.rect.colliderect(bullet.rect): # 如果两个矩形没有交点
bullet.kill() # 那么子弹出界，删除掉
def make_all_in_bound(self): # but remove outbound bullets
"""
当有非子弹实体将要移动出边界时，将它移回边界内
子弹实体出边界会销毁
:return:
"""
self.player.make_in_bound(self.room.rect)
for enemy in self.enemies:
enemy.make_in_bound(self.room.rect)
self.remove_outbound_bullets()
def update_everything(self):
dbgscreen.set_fps(int(self.clock.get_fps()))
self.player.update()
self.bullets_p.update()
self.bullets_e.update()
self.enemies.update()
self.make_all_in_bound()
def draw_everything(self):
# 先执行的绘画会在最底下
self.canvas.fill((220, 220, 220))
for enemy in self.enemies:
enemy.draw(self.canvas)
for bullet in self.bullets_p:
bullet.draw(self.canvas)
for bullet in self.bullets_e:
bullet.draw(self.canvas)
self.player.draw(self.canvas)
self.screen.blit(self.canvas, (0, 0), self.viewport)
if self.debug:
dbgscreen.draw(self.screen)
if not self.game_status:
self.play_button.draw()
def enemy_ai(self):
"""
总感觉这个名字取得不是很好。
调用所有敌人的ai()函数，处理它们的所有行动
:return:
"""
for enemy in self.enemies:
enemy.ai()
def game_restart(self):
"""
游戏重新启动:包括步骤：清空之前所有的数组
重新放入数组
"""
self.enemies.empty()
self.bullets_e.empty()
self.bullets_p.empty()
self.setup_entities()
def run(self):
while not self.done:
dbgscreen.show('(debug)bullet_count:{}'.format(
len(self.bullets_p) + len(self.bullets_e)))
self.handle_events()
self.check_everything()
"""
只有当游戏启动时敌人才会移动
数组才会更新
"""
if self.game_status: self.enemy_ai()
if self.game_status: self.update_everything()
self.draw_everything()
pygame.display.flip()
self.clock.tick(
setting.fps_limit) # 限制帧数。同时，只有用了tick，pygame内置的fps()才能使用
pygame.quit()
class UpdateChess:
def __init__(self, ai_settings, screen, chessboard):
self.ai_settings = ai_settings
self.screen = screen
self.chessboard = chessboard
self.white_chesses = Group()
self.black_chesses = Group()
self.over_chesses = Group()
self.color_chesses = Group()
self.map = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
self.chess_color = None
self.opposent_chess_color = None
self.can_discard = False
self.can_regret = False
self.time = 47
self.get_color_chess()
def add_oppose_chess(self, position):
"""
创建对手棋子
:param position: 对手棋子坐标
"""
if position:
y = position[0]
x = position[1]
new_chess = Chess(self.ai_settings, self.screen, self.chessboard,
x, y, self.opposent_chess_color)
self.black_chesses.add(new_chess)
self.map[y][x] = 2
self.can_discard = True
self.can_regret = False
self.time = 45
def game_over(self, over_list):
"""
根据游戏结束是棋子坐标创建结束位置棋子
:param over_list: 棋子坐标列表
"""
self.can_discard = False
self.count = 0
self.over_chesses.empty()
for index_y, index_x in over_list:
self.map[index_y][index_x] = 3
new_chess = Chess(self.ai_settings, self.screen, self.chessboard,
index_x, index_y, 3)
self.over_chesses.add(new_chess)
def check_events(self, click_button, game_status, regret_click_button,
regret_time):
""" 响应按键和鼠标事件 """
for event in pygame.event.get():
if event.type == pygame.QUIT:
os._exit(1)
elif event.type == pygame.MOUSEBUTTONDOWN: # 鼠标点击事件
if event.button == 1:
return self.do_mouse_button_down(click_button, event,
game_status,
regret_click_button,
regret_time)
def do_mouse_button_down(self, click_button, event, game_status,
regret_click_button, regret_time):
"""
处理鼠标点击按钮事件
:param click_button:
:param game_status:
:param event:
:return:
"""
for i in range(len(click_button)):
if click_button[i].rect.collidepoint(*event.pos):
result = self.do_normal_click(i, game_status, regret_time)
if result:
return result
result = self.do_regret_click(regret_click_button, event)
if result:
return result
return self.add_chess(event, regret_time)
def do_regret_click(self, regret_click_button, event):
for i in range(len(regret_click_button)):
if regret_click_button[i].rect.collidepoint(
*event.pos) and self.time <= 45:
if i == 0:
return "A"
if i == 1:
return "D"
def do_normal_click(self, i, game_status, regret_time):
if i == 0 and not game_status:
return "S"
if game_status and regret_time == 8:
if self.chess_color:
if i == 1:
return "G"
if i == 2 and not self.can_discard and self.can_regret:
return "R"
if not self.chess_color and i == 3:
return "Q"
def add_chess(self, event, regret_time):
"""
根据鼠标点击，如果点击位置没有棋子并且处于可下子状态，则增加棋子并返回索引
:param event:鼠标点击事件
:return:棋子位置索引坐标
"""
index_x = round(
(event.pos[0] - 24 - self.chessboard.rect.left) / 32.57)
index_y = round((event.pos[1] - 22 - self.chessboard.rect.top) / 32.57)
if 0 <= index_x <= 14 and 0 <= index_y <= 14:
if not self.map[index_y][
index_x] and self.can_discard and regret_time == 8:
new_chess = Chess(self.ai_settings, self.screen,
self.chessboard, index_x, index_y,
self.chess_color)
self.white_chesses.add(new_chess)
self.map[index_y][index_x] = 1
self.can_discard = False
self.can_regret = True
self.time = 45
return index_y, index_x
def update_screen(self, ai_settings, map, list_button):
"""
更新窗口
:param ai_settings:
:param map:
:param list_button:
:return:
"""
self.screen.fill(ai_settings.bg_color)
map.blitme()
self.update_chess()
self.update_button(list_button)
pygame.display.flip()
def update_button(self, list_button):
for item in list_button:
item.draw_button()
def update_chess(self):
"""
绘制棋子
:return:
"""
for chess in self.white_chesses.sprites():
chess.draw_chess()
for chess in self.black_chesses.sprites():
chess.draw_chess()
for chess in self.color_chesses.sprites():
chess.draw_chess()
for chess in self.over_chesses.sprites():
if 0 < self.count < 200 or 400 < self.count < 600:
chess.draw_chess()
self.count += 1
if self.count > 600:
self.over_chesses.empty()
def do_end_status(self):
self.white_chesses.empty()
self.black_chesses.empty()
self.color_chesses.empty()
for r in range(len(self.map)):
for c in range(len(self.map[0])):
self.map[r][c] = 0
self.chess_color = None
self.opposent_chess_color = None
self.time = 47
def do_opponent_agree(self, position):
for chess in self.white_chesses:
if self.index_is_same(chess, position):
self.white_chesses.remove(chess)
self.map[position[0]][position[1]] = 0
self.can_discard = True
self.can_regret = False
def index_is_same(self, chess, position):
return round((chess.rect.centerx - 24 - self.chessboard.rect.left) / 32.57) == position[1] and \
round((chess.rect.centery - 22 - self.chessboard.rect.top) / 32.57) == position[0]
def do_agree(self, position):
for chess in self.black_chesses:
if self.index_is_same(chess, position):
self.black_chesses.remove(chess)
self.map[position[0]][position[1]] = 0
self.can_discard = False
self.can_regret = True
def get_color_chess(self):
self.own_black_chess = Chess(self.ai_settings, self.screen,
self.chessboard, 13.5, 17.4, 1)
self.own_white_chess = Chess(self.ai_settings, self.screen,
self.chessboard, 13.5, 17.4, 2)
self.opponent_black_chess = Chess(self.ai_settings, self.screen,
self.chessboard, 0, -3.5, 1)
self.opponent_white_chess = Chess(self.ai_settings, self.screen,
self.chessboard, 0, -3.5, 2)
def add_color(self, chess_color):
if chess_color == 1:
self.color_chesses.add(self.own_black_chess)
self.color_chesses.add(self.opponent_white_chess)
else:
self.color_chesses.add(self.own_white_chess)
self.color_chesses.add(self.opponent_black_chess)
class Aliens:
def __init__(self, ship_height, game, barriers):
self.settings = game.settings
self.screen = game.screen
self.ship_height = ship_height
self.game = game
self.barriers = barriers
self.alien_group = Group()
self.ship_group = Group()
self.create_fleet()
self.bullet_group_that_kill_ship = Group()
self.last_bullet_shot = pg.time.get_ticks()
self.ship = None
def create_fleet(self):
settings, screen = self.settings, self.screen
alien = Alien(parent=self, game=self.game)
alien_width = alien.rect.width
alien_height = alien.rect.height
aliens_per_row = self.aliens_per_row(settings=settings,
alien_width=alien_width)
rows_per_screen = self.rows_per_screen(settings=settings,
alien_height=alien_height)
for y in range(rows_per_screen):
for x in range(aliens_per_row):
alien = Alien(
parent=self,
game=self.game,
number=y // 2,
x=alien_width * (4 + 1.5 * x), # 2//2 = 1. 3//2 = 1
y=alien_height * (1 + y))
self.alien_group.add(alien)
def aliens_per_row(self, settings, alien_width):
space_x = settings.screen_width - 2 * alien_width
return int(space_x / (2 * alien_width))
def rows_per_screen(self, settings, alien_height):
return 6
def add_bullet(self, game, x, y):
self.bullet_group_that_kill_ship.add(
BulletFromAlien(game=game, x=x, y=y))
def add(self, alien):
self.alien_group.add(alien)
def add_ship(self, ship):
self.ship = ship
self.ship_group.add(self.ship)
def empty(self):
self.alien_group.empty()
def group(self):
return self.alien_group
def remove(self, alien):
self.alien_group.remove(alien)
def change_direction(self):
for alien in self.alien_group:
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def check_edges(self):
for alien in self.alien_group.sprites():
if alien.check_edges():
return True
return False
def check_aliens_bottom(self):
r = self.screen.get_rect()
for alien in self.alien_group.sprites():
if alien.rect.bottom > r.bottom:
return True
return False
def one_alien_shoots_if_time(self):
now = pg.time.get_ticks()
if now > self.last_bullet_shot + self.settings.alien_bullets_every * 1000:
li = self.alien_group.sprites()
length = len(li)
shooter = li[randint(0, length - 1)]
self.add_bullet(game=self.game, x=shooter.x + 34, y=shooter.y)
self.last_bullet_shot = now
def update(self):
self.alien_group.update()
self.bullet_group_that_kill_ship.update()
bullet_ship_collisions = pg.sprite.groupcollide(
self.bullet_group_that_kill_ship, self.ship.group(), True, False)
if bullet_ship_collisions:
self.ship.dead = True
self.ship.killed()
bullet_barrier_collisions = pg.sprite.groupcollide(
self.barriers.group(), self.bullet_group_that_kill_ship, True,
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()
for bullet in self.bullet_group_that_kill_ship.copy():
if bullet.rect.bottom <= 0:
self.bullet_group_that_kill_ship.remove(bullet)
self.one_alien_shoots_if_time()
if self.check_edges():
self.change_direction()
if self.check_aliens_bottom() or pg.sprite.spritecollideany(
self.game.ship, self.alien_group):
self.game.reset()
return
for alien in self.alien_group.copy():
alien.update()
if alien.rect.bottom <= 0 or alien.reallydead:
self.alien_group.remove(alien)
def draw(self):
for alien in self.alien_group:
alien.draw()
for bullet in self.bullet_group_that_kill_ship:
bullet.draw()
class Game_functions():
def __init__(self):
self.ai_settings = Settings()
self.screen= pygame.display.set_mode((self.ai_settings.screen_width, self.ai_settings.screen_height))
self.ship = Ship(self.ai_settings , self.screen)
#子彈編組
self.bullets = Group()
#外星人
self.aliens = Group()
self.create_fleet()
self.stats = GameStats(self.ai_settings )
self.play_button = Button(self.ai_settings , self.screen , "Play")
self.sb = Scoreboard(self.ai_settings, self.screen , self.stats)
def check_keydown_events(self):
if self.event.key == pygame.K_RIGHT:
self.ship.moving_right = True
if self.event.key == pygame.K_LEFT:
self.ship.moving_left = True
if self.event.key == pygame.K_SPACE:
self.fire_bullet()
if self.event.key == pygame.K_q:
sys.exit()
def check_keyup_events(self):
if self.event.key == pygame.K_RIGHT:
self.ship.moving_right = False
if self.event.key == pygame.K_LEFT:
self.ship.moving_left = False
def check_events(self):
for self.event in pygame.event.get():
if self.event.type == pygame.QUIT:
sys.exit()
elif self.event.type == pygame.KEYDOWN:
self.check_keydown_events()
elif self.event.type == pygame.KEYUP:
self.check_keyup_events()
elif self.event.type == pygame.MOUSEBUTTONDOWN:
mouse_x , mouse_y = pygame.mouse.get_pos()
self.check_play_button( mouse_x, mouse_y)
#play 鍵按下
def check_play_button(self, mouse_x , mouse_y):
if self.play_button.rect.collidepoint(mouse_x, mouse_y) and not self.stats.game_active:
self.stats.reset_stats()
self.aliens.empty()
self.bullets.empty()
self.ship.center_ship()
self.create_fleet()
self.stats.game_active = True
self.ai_settings.initialize_dynamic_settings()
self.sb.prep_level()
self.sb.prep_score()
self.sb.prep_high_score()
self.sb.prep_ships()
pygame.mouse.set_visible(False)
def update_screen(self):
#畫面重新
self.screen.fill(self.ai_settings.bg_color)
self.update_ship()
self.update_bullets()
self.update_aliens()
if not self.stats.game_active:
self.play_button.draw_button()
self.sb.show_score()
#
pygame.display.flip()
def update_bullets(self):
#位置計算
self.bullets.update()
#子彈消失
for bullet in self.bullets.copy():
if bullet.rect.bottom <=0:
self.bullets.remove(bullet)
#每次都重繪
for bullet in self.bullets.sprites():
bullet.draw_bullet()
#是否撃中 ，擊中後就會自動刪除 groupcollide(group1, group2, dokill1, dokill2, collided = None) -> Sprite_dict
collisions = pygame.sprite.groupcollide(self.bullets,self.aliens , True, True )
if collisions :
self.stats.score += self.ai_settings.alien_point
self.sb.prep_score()
if self.stats.high_score < self.stats.score :
self.stats.high_score = self.stats.score
self.sb.prep_high_score()
if len(self.aliens) ==0 :
self.bullets.empty()
self.create_fleet()
self.ai_settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
def fire_bullet(self):
if len(self.bullets) < self.ai_settings.bullets_allowed:
new_bullet = Bullet(self.ai_settings, self.screen, self.ship)
self.bullets.add(new_bullet)
def update_ship(self):
#位置計算
self.ship.update()
#繪製
self.ship.blitme()
def create_fleet(self):
#外星人 建立
alien = Alien(self.ai_settings , self.screen)
alien_width = alien.rect.width
alien_height = alien.rect.height
available_space_x = self.ai_settings.screen_width -2 * alien_width
number_aliens_x = int(available_space_x /(2*alien_width))
available_space_y = self.ai_settings.screen_height - (3 * alien_height) -60
number_rows = int(available_space_y /(2*alien_height))
#行數
for row_number in range(number_rows):
#水平可放入幾個
for alien_number in range(number_aliens_x):
alien = Alien(self.ai_settings , self.screen )
alien.x = alien_width +2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height +2 * alien.rect.height * row_number
self.aliens.add(alien)
#外星人更新重繪
def update_aliens(self):
self.check_fleet_edges()
self.aliens.update()
self.aliens.draw(self.screen)
#是否碰觸
if pygame.sprite.spritecollideany(self.ship, self.aliens ):
self.ship_hit()
#是否觸底
self.ckeck_aliens_bottom()
def ckeck_aliens_bottom(self):
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom :
self.ship_hit()
break
#觸邊
def check_fleet_edges(self):
for alien in self.aliens.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
#方向改變
def change_fleet_direction(self):
self.ai_settings.fleet_direction *= -1
for alien in self.aliens.sprites():
alien.rect.y += self.ai_settings.fleet_drop_speed
#alien.ai_settings.fleet_direction = self.ai_settings.fleet_direction
#生命減1
def ship_hit(self):
if self.stats.ships_left >0 :
self.stats.ships_left -= 1
self.aliens.empty()
self.bullets.empty()
self.create_fleet()
self.ship.center_ship()
self.sb.prep_ships()
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
time.sleep(0.5)
def run_game():
global ch, yt
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()
alien = Alien(ai_settings, screen, alienbullets, alienBullet, ship)
aliens.add(alien)
libe = [1, 3, 4]
#do_liberint(ship,Alien,aliens,ai_settings,screen,libe,'robot.gif','supercat.gif','fire.gif',pygame)
bg_color = (20, 250, 200)
aliens.add(alien)
ship2 = Ship(ai_settings, screen)
ship2.rect.x = 2
ty = 0
ship2.rect.y = 2
imga = bg(ai_settings, screen)
ship.rect.x = 1112
ship.rect.y = 668
items = Group()
turrels = Group()
bullets2 = Group()
item = Ship(ai_settings, screen)
item.rect.y = randint(100, ai_settings.screen_height - 100)
item.rect.x = randint(100, ai_settings.screen_width - 100)
items.add(item)
bullets3 = Group()
bullets4 = Group()
turrels2 = Group()
while True:
turrels.empty()
turrels2.empty()
ty = 0
print('1p')
ty = randint(1, 3)
print(ty)
tre = randint(0, 10)
ty = 0
print('1p')
ty = randint(1, 3)
print(ty)
while True:
if ty == 100:
break
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:
if len(bullets) < 2:
ship.rect.x += 74
ty -= 1
if event.key == pygame.K_LEFT:
if len(bullets) < 2:
ship.rect.x -= 74
ty -= 1
if event.key == pygame.K_UP:
if len(bullets) < 2:
ship.rect.y -= 74
ty -= 1
if event.key == pygame.K_DOWN:
if len(bullets) < 2:
ship.rect.y += 74
ty -= 1
if event.key == pygame.K_RALT:
if len(bullets) < 1:
bul = Bullet(ai_settings, screen, ship, aliens,
bullets, ship2.rect.x,
ship2.rect.y)
bullets.add(bul)
if event.key == pygame.K_TAB:
ty = 0
#for event in pygame.event.get():
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_d:
if len(bullets2) < 2:
ship2.rect.x += 74
ty -= 1
if event.key == pygame.K_a:
if len(bullets2) < 2:
ship2.rect.x -= 74
ty -= 1
if event.key == pygame.K_w:
if len(bullets2) < 2:
ship2.rect.y -= 74
ty -= 1
if event.key == pygame.K_s:
if len(bullets2) < 2:
ship2.rect.y += 74
ty -= 1
if event.key == pygame.K_e:
if len(
bullets2
) < 1 and ship2.rect.y <= ship.rect.y + 540 and ship2.rect.x <= ship.rect.x + 540 and ship2.rect.y >= ship.rect.y - 540 and ship2.rect.x >= ship.rect.x - 540:
bul = Bullet(ai_settings, screen, ship2,
aliens, bullets, ship.rect.x,
ship.rect.y)
bullets2.add(bul)
if event.key == pygame.K_q:
if ship2.rect.y <= ship.rect.y + 180 and ship2.rect.x <= ship.rect.x + 180 and ship2.rect.y >= ship.rect.y - 180 and ship2.rect.x >= ship.rect.x - 180:
print('2p win')
sys.exit()
ty -= 1
if event.key == pygame.K_PAGEDOWN:
if ship2.rect.y <= ship.rect.y + 180 and ship2.rect.x <= ship.rect.x + 180 and ship2.rect.y >= ship.rect.y - 180 and ship2.rect.x >= ship.rect.x - 180:
print('1p win')
sys.exit()
if event.key == pygame.K_DELETE:
if len(
bullets
) < 1 and ship2.rect.y <= ship.rect.y + 540 and ship2.rect.x <= ship.rect.x + 540 and ship2.rect.y >= ship.rect.y - 540 and ship2.rect.x >= ship.rect.x - 540:
bul = Bullet(ai_settings, screen, ship, aliens,
bullets, ship2.rect.x,
ship2.rect.y)
bullets.add(bul)
# elif ship2.rect.y <= ship.rect.y-=103.92 and ship2.rect.x >= ship.rect.x-=103.92:
# print('1p win')
# ty = 1
if event.key == pygame.K_TAB:
ty = 0
#276 print(len(alienbullets))
# screen.fill(ai_settings.bg_color)
imga.blitme()
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)
for bullet in bullets2.sprites():
bullet.draw_bullet()
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
for bullet in bullets2.copy():
if bullet.rect.y == bullet.my and bullet.rect.x == bullet.mx:
bullets2.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx + 1:
bullets2.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx - 1:
bullets2.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx + 1:
bullets2.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx - 1:
bullets2.remove(bullet)
for bullet in bullets.copy():
if bullet.rect.y == bullet.my and bullet.rect.x == bullet.mx:
bullets.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx + 1:
bullets.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx - 1:
bullets.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx + 1:
bullets.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx - 1:
bullets.remove(bullet)
if pygame.sprite.spritecollideany(ship, bullets2):
print('2p win')
sys.exit()
if pygame.sprite.spritecollideany(ship2, bullets):
print('1p win')
sys.exit()
for bullet in bullets4.sprites():
bullet.draw_bullet()
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
for bullet in bullets3.sprites():
bullet.draw_bullet()
first = randint(0, 200)
second = randint(0, 200)
three = randint(0, 200)
ai_settings.bullet_color = (first, second, three)
for bullet in bullets4.copy():
if bullet.rect.y == bullet.my and bullet.rect.x == bullet.mx:
bullets4.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx + 1:
bullets4.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx - 1:
bullets4.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx + 1:
bullets4.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx - 1:
bullets4.remove(bullet)
for bullet in bullets3.copy():
if bullet.rect.y == bullet.my and bullet.rect.x == bullet.mx:
bullets3.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx + 1:
bullets3.remove(bullet)
if bullet.rect.y == bullet.my + 1 and bullet.rect.x == bullet.mx - 1:
bullets3.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx + 1:
bullets3.remove(bullet)
if bullet.rect.y == bullet.my - 1 and bullet.rect.x == bullet.mx - 1:
bullets3.remove(bullet)
if pygame.sprite.spritecollideany(ship, bullets4):
print('2p win')
if pygame.sprite.spritecollideany(ship2, bullets3):
print('1p win')
ship.blitme()
items.draw(screen)
bullets2.update()
bullets.update()
bullets3.update()
bullets4.update()
ship2.blitme()
turrels.draw(screen)
tre = randint(0, 100)
if pygame.sprite.spritecollideany(ship, items):
ty += 5
item2 = Ship(ai_settings, screen)
item2.rect.y = item.rect.y
item2.rect.x = item.rect.x
item.rect.y = randint(100, ai_settings.screen_height - 100)
item.rect.x = randint(100, ai_settings.screen_width - 100)
# item.rect.y = randint(100,ai_settings.screen_height-100)
# item.rect.x = randint(100,ai_settings.screen_width-100)
turrels.add(item2)
if pygame.sprite.spritecollideany(ship2, items):
ty += 5
item2 = Ship(ai_settings, screen)
item2.rect.y = item.rect.y
item2.rect.x = item.rect.x
item.rect.y = randint(100, ai_settings.screen_height - 100)
item.rect.x = randint(100, ai_settings.screen_width - 100)
# item.rect.y = randint(100,ai_settings.screen_height-100)
# item.rect.x = randint(100,ai_settings.screen_width-100)
turrels2.add(item2)
item2.image = pygame.image.load('supercat.gif')
turrels.draw(screen)
turrels2.draw(screen)
pygame.display.flip()
ty = 0
print('2p')
ty = randint(1, 3)
print(ty)
while True:
if ty <= 0:
break
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:
ship2.rect.x += 74
ty -= 1
if event.key == pygame.K_LEFT:
ship2.rect.x -= 74
ty -= 1
if event.key == pygame.K_UP:
ship2.rect.y -= 74
ty -= 1
if event.key == pygame.K_DOWN:
ship2.rect.y += 74
ty -= 1
if event.key == pygame.K_g:
if ship2.rect.y <= ship.rect.y + 180 and ship2.rect.x <= ship.rect.x + 180 and ship2.rect.y >= ship.rect.y - 180 and ship2.rect.x >= ship.rect.x - 180:
print('2p win')
ty -= 1
# elif ship2.rect.y <= ship.rect.y-=103.92 and ship2.rect.x >= ship.rect.x-=103.92:
# print('1p win')
# ty = 1
else:
print('you cant do it')
if event.key == pygame.K_TAB:
ty = 0
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 print(len(alienbullets))
imga.blitme()
ship.blitme()
ship2.blitme()
items.empty()
pygame.display.flip()
class Game(object):
def __init__(self, width=400, height=300, bgColor=(0, 0, 0)):
self.width = width
self.height = height
self.bgColor = bgColor
self.enemyFireId = pygame.USEREVENT+1
pygame.init()
self.screen = pygame.display.set_mode((self.width, self.height))
self.myTank = MyTank(self.screen)
self.bullets = Group()
self.clock = Clock()
self.enemys = Group()
self.enemyBullets = Group()
for i in range(1, 5):
enemy = EnemyTank(75 * i, 30)
self.enemys.add(enemy)
self.bomb = Bomb()
# 游戏结束的标志
self.stop = False
# 设置定时器
pygame.time.set_timer(self.enemyFireId,800)
# 游戏结束显示的文字
myFont = pygame.font.SysFont("simhei", 24)
self.fontImage = myFont.render("游戏结束！", True, (0, 255, 0))
# 事件处理
def handleEvent(self):
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit(0)
# 开始游戏
elif event.type == self.enemyFireId:
for enemy in self.enemys:
self.enemyBullets.add(enemy.fire())
elif event.type == KEYDOWN:
if event.key == K_a or event.key == K_LEFT:
self.myTank.setDirection(-1)
elif event.key == K_d or event.key == K_RIGHT:
self.myTank.setDirection(1)
elif event.key == K_w or event.key == K_UP:
self.myTank.move()
elif event.key == K_SPACE:
self.bullets.add(self.myTank.fire())
def run(self):
while True:
self.clock.tick(15)
self.handleEvent()
self.screen.fill(self.bgColor)
if not self.stop:
self.myTank.update(self.screen)
if len(self.enemys.sprites()) < 4:
enemy = EnemyTank(80 * randint(1,4), 30)
self.enemys.add(enemy)
self.enemys.update(self.screen)
for enemy in self.enemys:
enemy.random_move()
self.enemyBullets.update(self.screen)
self.enemyBullets.update(self.screen)
self.bullets.update(self.screen)
# self.bomb.update(self.screen,30,30)
pygame.sprite.groupcollide(self.bullets, self.enemyBullets, True, True)
collisions = pygame.sprite.groupcollide(self.bullets, self.enemys, True, True)
for bullet in collisions.keys():
bomb_rect = bullet.rect
self.bomb.update(self.screen,bomb_rect.x,bomb_rect.y)
if pygame.sprite.spritecollideany(self.myTank,self.enemyBullets):
self.bomb.update(self.screen, self.myTank.rect.x, self.myTank.rect.y)
self.myTank.kill()
self.enemys.empty()
self.enemyBullets.empty()
self.bullets.empty()
self.stop = True
if pygame.sprite.spritecollideany(self.myTank, self.enemys):
self.bomb.update(self.screen, self.myTank.rect.x, self.myTank.rect.y)
self.myTank.kill()
self.enemys.empty()
self.enemyBullets.empty()
self.bullets.empty()
self.stop = True
else:
self.screen.blit(self.fontImage,(self.screen.get_rect().centerx
-self.fontImage.get_rect().centerx,self.screen.get_rect().centery
-self.fontImage.get_rect().centery))
pygame.display.update()
def run_game():
#游戏初始化
pygame.init()
# 初始化混音器模块
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)
#创建屏幕对象
ai_settings = Settings()
# 创建一个用于存储游戏统计信息的实例
stats = GameStats(ai_settings)
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption(('奥特曼之保卫地球'))
# 添加音效
pygame.mixer.music.load('sound/bgm.mp3')
# loops = -1，表示无限重复播放
pygame.mixer.music.play(-1)
# 创建Play按钮
play_button = Button(ai_settings, screen, 'Play')
# # 创建GameOver
# GameOver_button = Button(ai_settings, screen, 'Game Over!')
# 创建飞船
ship = Ship(ai_settings, screen)
# 创建子弹组
bullets = Group()
# 创建冲击波组
impacts = Group()
# 创建激光
laser = Group()
laser.add(Laser(ai_settings, screen))
# 创建敌人
aliens = Group()
# 创建爆炸
explosions = [Explosion(ai_settings, screen) for _ in range(20)]
# 创建一个时间对象,设置帧率为 200
fps = 150
Game_clock = pygame.time.Clock()
# 开始游戏主循环
while True:
gf.check_events(ai_settings, screen, stats, play_button, ship, aliens,
bullets, impacts)
if ship.hp <= 0:
pygame.mouse.set_visible(True)
stats.game_active = False
ai_settings.speed_reset()
ai_settings.speedchange()
if stats.game_active:
stats.reset_stats()
if stats.game_active:
if len(aliens) == 0:
ai_settings.speedup()
ai_settings.speedchange()
gf.create_fleet(ai_settings, screen, ship, aliens)
ship.update()
hit = gf.update_alien(ai_settings, ship, aliens)
if hit:
aliens.empty()
continue
gf.update_impact(ai_settings, stats, aliens, impacts, explosions)
gf.update_laser(ai_settings, stats, laser, ship, aliens,
explosions)
gf.update_bullets(ai_settings, stats, aliens, bullets, explosions)
gf.update_explosion(explosions)
# 调用Clock()类创建的对象中的tick()函数
Game_clock.tick(fps)
gf.update_screen(ai_settings, screen, stats, ship, aliens, bullets,
laser, impacts, explosions, play_button)
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 = (255, 255, 255)
self.font = pygame.font.SysFont(None, 25)
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()
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.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.ships = Group()
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships()
def prep_level(self):
self.level_rect.right = self.score_rect.right
self.level_rect.top = self.score_rect.bottom + 10
def prep_ships(self):
self.ships.empty()
for number_ship in range(self.stats.ships_left):
ship = Ship(self.ai_settings, self.screen)
ship.rect.x = 10 + number_ship * ship.rect.width
ship.rect.y = 10
self.ships.add(ship)
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.centerx = self.screen_rect.centerx
self.high_score_rect.top = self.score_rect.top
def prep_score(self):
rounded_score = int(round(self.stats.score, -1))
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render(score_str, True, self.text_color,
self.ai_settings.bg_color)
self.score_rect.right = self.screen_rect.right - 60
self.score_rect.top = 20
def show_score(self):
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
self.ships.draw(self.screen)
class Ship(Sprite):
images = [pg.image.load('images/ship.bmp')]
images_boom = [
pg.image.load('images/ship_boom' + str(i) + '.png') for i in range(4)
]
timer = Timer(frames=images, wait=1000)
timer_boom = Timer(frames=images_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 group(self):
return self.ship_group
def killed(self):
if 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.frame_index() == len(Ship.images_boom) - 1:
self.dead = False
self.timer_switched = False
self.reallydead = True
self.timer.reset()
self.game.reset()
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.dead = True
alien.killed()
bullet_barrier_collisions = pg.sprite.groupcollide(
self.barriers.group(), self.bullet_group_that_kill_aliens, True,
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.centerx,
y=self.rect.top)
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.x, self.rect.y
self.screen.blit(image, rect)
def runGame():
# Initialize game and create a window
pg.init()
# create a new object using the settings class
setting = Settings()
# creaete a new object from pygame display
screen = pg.display.set_mode((setting.screenWidth, setting.screenHeight))
# intro
intro.introimages()
# set window caption using settings obj
pg.display.set_caption(setting.windowCaption)
bMenu = ButtonMenu(screen)
bMenu.addButton("play", "PLAY")
bMenu.addButton("menu", "BACK")
bMenu.addButton("twoPlay", "2PVS")
bMenu.addButton("settings", "SETTINGS")
bMenu.addButton("invert", "INVERT")
bMenu.addButton("about", "ABOUT")
bMenu.addButton("quit", "QUIT")
bMenu.addButton("grey", "GREY")
bMenu.addButton("red", "RED")
bMenu.addButton("blue", "BLUE")
bMenu.addButton("retry", "RETRY")
bMenu.addButton("hard", "HARD")
bMenu.addButton("normal", "NORMAL")
bMenu.addButton("back", "MENU")
bMenu.addButton("speed setting", "SPEED")
bMenu.addButton("fast", "FAST")
bMenu.addButton("middle", "MIDDLE")
bMenu.addButton("slow", "SLOW")
bMenu.addButton("yes", "YES")
bMenu.addButton("no", "NO")
bMenu.addButton("interception", "INTERCEPT")
bMenu.addButton("sound", "SOUND")
bMenu.addButton("loud", "LOUD")
bMenu.addButton("low", "LOW")
mainMenuButtons = ["play", "about", "settings", "quit"] # delete "twoPlay"
playMenuButtons = ["grey", "red", "blue", "menu", "quit"]
levelMenuButtons = ["hard", "normal", "back", "quit"]
mainGameButtons = ["play", "menu", "quit"]
aboutButtons = ["menu", "quit"]
soundButtons = ["loud", "low", "menu"]
settingsMenuButtons = [
"menu", "invert", "speed setting", "interception", "quit"
]
speedButtons = ["menu", "fast", "middle", "slow"]
bgManager = BackgroundManager(screen)
bgManager.setFillColor((0, 0, 0))
bgManager.addBackground("universe_1", "gfx/backgrounds/stars_back.png", 0,
1)
bgManager.addBackground("universe_1", "gfx/backgrounds/stars_front.png", 0,
1.5)
bgManager.selectBackground("universe_1")
# Create an instance to stor game stats
stats = GameStats(setting)
sb = Scoreboard(setting, screen, stats)
# Make a ship
ship = Ship(setting, screen)
# Ships for two player
ship1 = Ship(setting, screen)
ship2 = Ship(setting, screen)
# make a group of items to store
items = Group()
# make a group of bullets to store
bullets = Group()
charged_bullets = Group()
eBullets = Group()
setting.explosions = Explosions()
# Make an alien
aliens = Group()
gf.createFleet(setting, stats, screen, ship, aliens)
pg.display.set_icon(pg.transform.scale(ship.image, (32, 32)))
bgImage = pg.image.load('gfx/title_c.png')
bgImage = pg.transform.scale(bgImage,
(setting.screenWidth, setting.screenHeight))
bgImageRect = bgImage.get_rect()
aboutImage = pg.image.load('gfx/About_modify2.png')
aboutImage = pg.transform.scale(
aboutImage, (setting.screenWidth, setting.screenHeight))
aboutImageRect = aboutImage.get_rect()
# plays bgm
pg.mixer.music.load('sound_bgms/galtron.mp3')
pg.mixer.music.set_volume(0.25)
pg.mixer.music.play(-1)
rungame = True
sounds.stage_clear.play()
# Set the two while loops to start mainMenu first
while rungame:
# Set to true to run main game loop
bMenu.setMenuButtons(mainMenuButtons)
while stats.mainMenu:
if not stats.gameActive and stats.paused:
setting.initDynamicSettings()
stats.resetStats()
##stats.gameActive = True
# Reset the alien and the bullets
aliens.empty()
bullets.empty()
eBullets.empty()
# Create a new fleet and center the ship
gf.createFleet(setting, stats, screen, ship, aliens)
ship.centerShip()
mm.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets)
mm.drawMenu(setting, screen, sb, bMenu, bgImage, bgImageRect)
bMenu.setMenuButtons(levelMenuButtons)
while stats.levelMenu:
lm.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets)
lm.drawMenu(setting, screen, sb, bMenu, bgImage, bgImageRect)
bMenu.setMenuButtons(playMenuButtons)
while stats.playMenu:
pm.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets)
pm.drawMenu(setting, screen, sb, bMenu)
bMenu.setMenuButtons(mainGameButtons)
while stats.mainGame:
# Game functions
gf.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets,
charged_bullets) # Check for events
# Reset Game
if gf.reset == 1:
gf.reset = 0
pg.register_quit(runGame())
if stats.gameActive:
gf.updateAliens(setting, stats, sb, screen, ship, aliens,
bullets, eBullets) # Update aliens
gf.updateBullets(setting, screen, stats, sb, ship, aliens,
bullets, eBullets, charged_bullets,
items) # Update collisions
gf.updateItems(setting, screen, stats, sb, ship, aliens,
bullets, eBullets, items)
ship.update(bullets, aliens) # update the ship
# Update the screen
gf.updateScreen(setting, screen, stats, sb, ship, aliens, bullets,
eBullets, charged_bullets, bMenu, bgManager, items)
bMenu.setMenuButtons(aboutButtons)
bMenu.setPos(None, 500)
while stats.mainAbout:
About.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets)
About.drawMenu(setting, screen, sb, bMenu, aboutImage,
aboutImageRect)
while stats.twoPlayer:
tp.checkEvents(setting, screen, stats, sb, bMenu, bullets, aliens,
eBullets, ship1, ship2)
if stats.gameActive:
ship1.update(bullets, aliens)
ship2.update(bullets, aliens)
tp.updateBullets(setting, screen, stats, sb, ship1, ship2,
aliens, bullets, eBullets, items)
tp.updateScreen(setting, screen, stats, sb, ship1, ship2, aliens,
bullets, eBullets, bMenu, items)
bMenu.setMenuButtons(settingsMenuButtons)
while stats.settingsMenu:
sm.checkEvents1(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets)
sm.drawMenu(setting, screen, sb, bMenu)
bMenu.setMenuButtons(speedButtons)
while stats.speedMenu:
spm.checkEvents(setting, screen, stats, sb, bMenu, ship, aliens,
bullets, eBullets)
spm.drawMenu(setting, screen, sb, bMenu)
while stats.mainGame:
if rungame == True:
print("test")
def run_game():
global bullets_die
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alien Invasion')
ship = Ship(ai_settings, screen)
bullets = Group()
alienbullets = Group()
blocks = Group()
stats = GameStats(ai_settings)
aliens = Group()
alien = Alien(ai_settings, screen)
alien_width = alien.rect.width
available_spase_x = ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_spase_x / (2 * alien_width))
number_rows = get_number_rows(ai_settings, ship.rect.height,
alien.rect.height)
alien.y = -90
alien.rect.y = alien.y
for bloc in range(3):
block = Block(ai_settings, screen)
block.y = 600
block.x = bloc * 450
block.rect.x = block.x
block.rect.y = block.y
blocks.add(block)
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
# print(alien.rect.y)
create_alien(ai_settings, screen, aliens, alien_number, row_number)
# aliens.add(alien)
bg_color = (20, 250, 200)
while True:
# print(alien.rect.y)
# tre = randint(-1000,1000)
# if tre == 1:
# alien.y = 0
# create_alien(ai_settings,screen,aliens,alien_number,row_number)
# if tre >= 990:
# bullets_die = False
# for row_number in range(number_rows):
# for alien_number in range(number_aliens_x):
# # print(alien.rect.y)
# create_alien(ai_se
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
new_bullet = Bullet(ai_settings, screen, ship, aliens, bullets,
alien, mouse_x, mouse_y)
bullets.add(new_bullet)
new_bullet.draw_bullet()
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_v:
for alien in aliens.sprites():
new_bullet = Bullet(ai_settings, screen, ship, aliens,
bullets, alien, alien.rect.x,
alien.rect.y)
bullets.add(new_bullet)
new_bullet.draw_bullet()
if event.key == pygame.K_RIGHT:
ship.movin_right = True
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
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if ship.rect.collidepoint(mouse_x, mouse_y):
ship.image = pygame.image.load(choice(images))
bullets.update()
ship.update()
blocks.update()
aliens.update()
for alien in aliens.sprites():
tre = randint(-1000, 5000)
if tre == 0:
new_bullet = alienBullet(ai_settings, screen, alien)
alienbullets.add(new_bullet)
ship.blitme()
alienbullets.update(bullets, aliens)
alienbullets.update(bullets, aliens)
aliens.draw(screen)
blocks.draw(screen)
pygame.display.flip()
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()
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)
collisions = pygame.sprite.groupcollide(bullets, blocks, True,
False)
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)
chek_fleet_edges(ai_settings, aliens)
if pygame.sprite.spritecollideany(ship, aliens):
ship_hit(ai_settings, stats, screen, ship, aliens, bullets)
pygame.display.flip()
def run_game():
global bullets_die
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alien Invasion')
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
ships = Group()
ships.add(ship)
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:
#pygame.mouse.set_visible(False)
# 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.MOUSEBUTTONUP:
mouse_x, mouse_y = pygame.mouse.get_pos()
new_bullet = Bullet(ai_settings, screen, ship, mouse_x,
mouse_y)
bullets.add(new_bullet)
set_sta.set_state(new_bullet, mouse_x, mouse_y)
collisions = pygame.sprite.groupcollide(ships, aliens, False, True)
#help(pygame.Mask)
#pygame.Mask(size=(mouse_x, mouse_y), fill=False)
#bullets.add(new_bull
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()
def run_game():
global bullets_die
pygame.init()
b = 0
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.y = -90
tre = 0
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:
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
# pygame.mouse.set_visible(False)
ai_settings.initialise()
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
if b == 1:
print("I")
mouse_x, mouse_y = pygame.mouse.get_pos()
new_bullet = Bullet(ai_settings, screen, ship, aliens, bullets,
alien, mouse_x, mouse_y)
bullets.add(new_bullet)
for event in pygame.event.get():
#for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_f:
b = 1
print(b)
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_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_f:
b = 0
if event.key == pygame.K_RIGHT:
ship.movin_right = False
if event.key == pygame.K_LEFT:
ship.movin_left = False
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if ship.rect.collidepoint(mouse_x, mouse_y):
ship.image = pygame.image.load(choice(images))
bullets.update()
ship.update()
aliens.update()
ship.blitme()
alienbullets.update(bullets, aliens)
alienbullets.update(bullets, aliens)
aliens.draw(screen)
ship.blitme()
pygame.display.flip()
for bullet in bullets.copy():
if bullet.rect.x <= bullet.mouse_x and bullet.rect.y == bullet.mouse_y:
bullets.remove(bullet)
print(len(bullets))
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)
ai_settings.increase_speed()
ship.blitme()
bullets.update()
aliens.draw(screen)
chek_fleet_edges(ai_settings, aliens)
if pygame.sprite.spritecollideany(ship, aliens):
ship_hit(ai_settings, stats, screen, ship, aliens, bullets)
if pygame.sprite.spritecollideany(ship, alienbullets):
ship_hit(ai_settings, stats, screen, ship, aliens, bullets)
alienbullets.empty()
aliens.draw(screen)
pygame.display.flip()
class Maze:
"""Build and hold all components of the maze."""
def __init__(self, screen, game_settings, maze_file, sprite_sheet, pacman,
sounds):
"""Initialize instance attributes."""
self.screen = screen
self.game_settings = game_settings
self.maze_file = maze_file
self.sprite_sheet = sprite_sheet
self.pacman = pacman
self.sounds = sounds
self.maze_rows = []
self.x_offset = 0
self.y_offset = 60
self.walls = Group()
self.dots = Group()
self.power_dots = Group()
self.shields = Group()
self.nodes = Group()
self.fruits = Group()
self.portals = Group()
self.ghosts = Group()
self.bullets = Group()
self.a_star = None
self.time_elapsed = 2000
self.animate_ghosts = 0
self.bullet_indicator = 0
self.create_blue_portal = False
self.create_red_portal = False
self.blue_bullet_position = None
self.red_bullet_position = None
for row in maze_file:
self.maze_rows.append(row)
maze_file.close()
def build_maze(self):
"""Build the maze according to the maze layout file."""
self.ghosts.empty()
self.dots.empty()
self.power_dots.empty()
self.shields.empty()
self.fruits.empty()
self.walls.empty()
self.bullets.empty()
self.portals.empty()
maze_layout = self.maze_rows
for row in maze_layout:
for char in row:
if char == 'W':
wall = MazeImage(screen=self.screen,
image=self.sprite_sheet.wall_image)
wall.rect.x += self.x_offset
wall.rect.y += self.y_offset
self.walls.add(wall)
elif char == '.':
dot = MazeImage(screen=self.screen,
image=self.sprite_sheet.dot_image)
dot.rect.x += self.x_offset
dot.rect.y += self.y_offset
self.dots.add(dot)
point = Point(x=self.x_offset + 7, y=self.y_offset + 7)
node = Node(position=point, rect=dot.rect)
self.nodes.add(node)
elif char == ',':
dot = MazeImage(screen=self.screen,
image=self.sprite_sheet.dot_image)
dot.rect.x += self.x_offset
dot.rect.y += self.y_offset
point = Point(x=self.x_offset + 7, y=self.y_offset + 7)
node = Node(position=point, rect=dot.rect)
self.nodes.add(node)
elif char == 'o':
power_dot = MazeImage(
screen=self.screen,
image=self.sprite_sheet.power_dot_image)
power_dot.rect.x += self.x_offset
power_dot.rect.y += self.y_offset
self.power_dots.add(power_dot)
point = Point(x=self.x_offset + 7, y=self.y_offset + 7)
node = Node(position=point, rect=power_dot.rect)
self.nodes.add(node)
elif char == '-':
shield = MazeImage(screen=self.screen,
image=self.sprite_sheet.shield_image)
shield.rect.x += self.x_offset
shield.rect.y += self.y_offset
self.shields.add(shield)
point = Point(x=self.x_offset + 7, y=self.y_offset + 7)
node = Node(position=point, rect=shield.rect)
self.nodes.add(node)
elif char == 'F':
fruit = MazeImage(screen=self.screen,
image=self.sprite_sheet.fruit_image)
fruit.rect.x += self.x_offset
fruit.rect.y += self.y_offset - 5
fruit_rect = self.sprite_sheet.shield_image.get_rect()
self.fruits.add(fruit)
point = Point(x=self.x_offset + 7, y=self.y_offset + 7)
node = Node(position=point, rect=fruit_rect)
self.nodes.add(node)
self.x_offset += 15
self.x_offset = 0
self.y_offset += 15
self.a_star = AStar()
self.a_star.create_nodes(nodes=self.nodes.sprites())
self.create_ghosts()
self.y_offset = 60
def create_ghosts(self):
"""Create the ghosts that hunt pacman."""
ghost = Ghost(screen=self.screen,
game_settings=self.game_settings,
image_list=self.sprite_sheet.blinky_image,
scared_image=self.sprite_sheet.ghost_dead_image,
blink_image=self.sprite_sheet.blink_image,
start_position=self.nodes.sprites()[189].position,
indicator=0,
a_star=self.a_star,
pacman=self.pacman,
nodes=self.nodes)
self.ghosts.add(ghost)
ghost = Ghost(screen=self.screen,
game_settings=self.game_settings,
image_list=self.sprite_sheet.pinky_image,
scared_image=self.sprite_sheet.ghost_dead_image,
blink_image=self.sprite_sheet.blink_image,
start_position=self.nodes.sprites()[242].position,
indicator=1,
a_star=self.a_star,
pacman=self.pacman,
nodes=self.nodes)
self.ghosts.add(ghost)
ghost = Ghost(screen=self.screen,
game_settings=self.game_settings,
image_list=self.sprite_sheet.inky_image,
scared_image=self.sprite_sheet.ghost_dead_image,
blink_image=self.sprite_sheet.blink_image,
start_position=self.nodes.sprites()[246].position,
indicator=2,
a_star=self.a_star,
pacman=self.pacman,
nodes=self.nodes)
self.ghosts.add(ghost)
ghost = Ghost(screen=self.screen,
game_settings=self.game_settings,
image_list=self.sprite_sheet.clyde_image,
scared_image=self.sprite_sheet.ghost_dead_image,
blink_image=self.sprite_sheet.blink_image,
start_position=self.nodes.sprites()[249].position,
indicator=3,
a_star=self.a_star,
pacman=self.pacman,
nodes=self.nodes)
self.ghosts.add(ghost)
def blit(self):
"""Draw the maze and its components to the screen."""
self.walls.draw(self.screen)
self.dots.draw(self.screen)
self.power_dots.draw(self.screen)
self.shields.draw(self.screen)
self.fruits.draw(self.screen)
self.portals.draw(self.screen)
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.ghosts.draw(self.screen)
def update_ghosts(self):
"""Update ghost positions, give them new paths, manage timers for animation switching."""
if self.pacman.power_up:
if self.time_elapsed >= 600 and self.time_elapsed % 50 == 0:
for ghost in self.ghosts:
ghost.blink()
if self.time_elapsed % 200 == 0:
if self.pacman.current_position.x > self.screen.get_rect(
).centerx:
if self.pacman.current_position.y > self.screen.get_rect(
).centery:
goal = self.nodes.sprites()[1].position
else:
goal = self.nodes.sprites()[488].position
else:
if self.pacman.current_position.y > self.screen.get_rect(
).centery:
goal = self.nodes.sprites()[37].position
else:
goal = self.nodes.sprites()[529].position
for ghost in self.ghosts:
if not ghost.is_dead:
ghost.gen_new_path(scared=True, goal=goal)
else:
for ghost in self.ghosts:
if ghost.is_scared:
ghost.restore()
if self.time_elapsed >= 2000:
for ghost in self.ghosts.sprites():
ghost.gen_new_path(scatter=True)
self.time_elapsed = 0
if self.animate_ghosts >= 200:
for ghost in self.ghosts.sprites():
ghost.switch_image()
self.animate_ghosts = 0
for ghost in self.ghosts.sprites():
ghost.update()
self.time_elapsed += 1
self.animate_ghosts += 1
def fire_bullet(self):
"""Fire portal gun bullet from pacman."""
if len(self.bullets) < 2 and self.pacman.current_position is not None:
if self.bullet_indicator == 0:
self.sounds.blue_portal.play()
new_bullet = Bullet(game_settings=self.game_settings,
screen=self.screen,
bullet_color=(96, 166, 249),
indicator=self.bullet_indicator,
pacman=self.pacman)
self.bullets.add(new_bullet)
self.bullet_indicator = 1
else:
self.sounds.red_portal.play()
new_bullet = Bullet(game_settings=self.game_settings,
screen=self.screen,
bullet_color=(254, 163, 89),
indicator=self.bullet_indicator,
pacman=self.pacman)
self.bullets.add(new_bullet)
self.bullet_indicator = 0
def update_bullets(self):
"""Update current bullet positions, check for collisions."""
for bullet in self.bullets:
bullet.update()
self.check_bullet_node_collision()
self.check_bullet_wall_collision()
def check_bullet_node_collision(self):
"""Check a bullets last node collision and sets that to it's previous position."""
for bullet in self.bullets.sprites():
collisions = pygame.sprite.spritecollide(bullet, self.nodes, False)
if collisions:
bullet.previous_position = collisions[0]
def check_bullet_wall_collision(self):
"""Check if a bullet collides with a wall, destroys bullet, creates a portal."""
for bullet in self.bullets.sprites():
collisions = pygame.sprite.spritecollide(bullet, self.walls, False)
if collisions:
if bullet.indicator == 0:
self.create_blue_portal = True
self.blue_bullet_position = bullet.previous_position
else:
self.create_red_portal = True
self.red_bullet_position = bullet.previous_position
bullet.kill()
def update_portals(self):
"""Check if portals need to be closed."""
portal_position = None
if self.create_blue_portal:
for portal in self.portals.sprites():
if portal.indicator == 0:
portal.closing_portal = True
else:
portal_position = portal.position
portal.other_portal = self.blue_bullet_position
new_portal = Portal(screen=self.screen,
image_list=self.sprite_sheet.blue_portal,
position=self.blue_bullet_position,
indicator=0,
other_portal=portal_position)
self.portals.add(new_portal)
self.create_blue_portal = False
if self.create_red_portal:
for portal in self.portals.sprites():
if portal.indicator == 1:
portal.closing_portal = True
else:
portal_position = portal.position
portal.other_portal = self.red_bullet_position
new_portal = Portal(screen=self.screen,
image_list=self.sprite_sheet.red_portal,
position=self.red_bullet_position,
indicator=1,
other_portal=portal_position)
self.portals.add(new_portal)
self.create_red_portal = False
self.portals.update()
class Main(object):
"""
creates and recieves input from the GUI
"""
SCREEN_SIZE = 800,600
FPS = 30
def __init__(self):
"""
no gui stuff yet, finishing the core components
"""
self.ROOT_DIR = os.path.dirname(sys.argv[0])
self.IMG_DIR = os.path.join(self.ROOT_DIR, "images")
self.DATA_DIR = os.path.join(self.ROOT_DIR, "database")
self.dbm = DataBaseManager(self.DATA_DIR)
pygame.init()
pygame.font.init()
self.MAIN_SCREEN = pygame.display.set_mode(self.SCREEN_SIZE)
self.MAIN_SCREEN_RECT = self.MAIN_SCREEN.get_rect()
self.openingImage,self.openingImageRect = loadImage(self.IMG_DIR, "GrocerySpy.jpg")
self.MAIN_SCREEN.blit(self.openingImage,
(self.MAIN_SCREEN_RECT.centerx - self.openingImageRect.width /2,
self.MAIN_SCREEN_RECT.centery - self.openingImageRect.height /2))
## make button here
startButton = Button(self.IMG_DIR, "textButton", (300,475), "menu", -1)
startButton.addText("Start Here")
# add that button to the list
self.buttonGroup = Group(startButton)
self.windowGroup = Group()
self.state = "prestart"
self.stateChanged = False
# set key repeats for scrolling windows
pygame.key.set_repeat(20, 20)
self.groceryList = GroceryList()
# variable for storing the state of the browseAll window if it is left
self.toggledRecipeNames = []
self.controlHeld = False
self.pasteDelayReset = 1000
self.pasteDelay = self.pasteDelayReset
def run(self):
done = False
while not done:
## input loop
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
## right click anything to have a pop up window
# appear at the cursor with more information about the thing
elif event.type == MOUSEBUTTONDOWN and event.button == 1:
self.handleLeftMouseClick(pygame.mouse.get_pos())
## arrow keys
elif event.type == KEYDOWN and event.key == K_DOWN:
self.attemptScroll(-3)
elif event.type == KEYDOWN and event.key == K_UP:
self.attemptScroll(3)
elif event.type == KEYDOWN and (event.key == K_RCTRL or event.key == K_LCTRL):
self.controlHeld = True
elif event.type == KEYUP and (event.key == K_RCTRL or event.key == K_LCTRL):
self.controlHeld = False
elif event.type == KEYDOWN and event.key == K_v:
if self.controlHeld:
if self.pasteDelay < 10:
self.doPaste()
self.pasteDelay = self.pasteDelayReset
## end input
if self.pasteDelay > 0:
self.pasteDelay -= 1
## change screen
if self.stateChanged:
## clear everything on the screen first
self.buttonGroup.empty()
self.windowGroup.empty()
self.MAIN_SCREEN.fill((0,0,0))
self.stateChanged = False
if self.state == "menu":
self.createMenu()
elif self.state == "browseAll":
self.setUpViewAll()
elif self.state == "viewGroceryList":
self.setUpViewGroceryList()
elif self.state == "addRecipe":
#print "here"
self.setUpRecipeAdder()
elif self.state == "search":
self.setUpSearchTextBox()
elif self.state == "deleteRecipe":
self.setUpDelete()
elif self.state == "exit":
done = True
## do stuff to update the new state
# after updates, draw
self.buttonGroup.draw(self.MAIN_SCREEN)
self.windowGroup.draw(self.MAIN_SCREEN)
pygame.display.flip()
pygame.quit()
def setUpViewAll(self):
x,y = self.SCREEN_SIZE
x-=100
viewAllWindow = ScrollableWindow(self.IMG_DIR, (x,y),self.SCREEN_SIZE, "recipeViewer")
viewAllWindow.addText(self.dbm.getAllRecipes())
#viewAllWindow.addText(self.dbm.getRandomRecipe())
viewAllWindow.updateState(self.toggledRecipeNames)
self.windowGroup.add(viewAllWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
## in one command, we call getAllRecipes() on the DBM, returning
# a string list of all the names, and pass that to the
# scrollable window to add that text to the thing
# this returns the expandButtons for each row, which we add
# to the buttonGroup
def setUpDelete(self):
x,y = self.SCREEN_SIZE
x-=100
viewAllWindow = ScrollableWindow(self.IMG_DIR, (x,y),self.SCREEN_SIZE, "recipeDeleter")
viewAllWindow.addText(self.dbm.getAllRecipes())
self.windowGroup.add(viewAllWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
def setUpViewGroceryList(self):
x,y = self.SCREEN_SIZE
x-=100
viewAllWindow = ScrollableWindow(self.IMG_DIR, (x,y),self.SCREEN_SIZE, "groceryListViewer")
self.windowGroup.add(viewAllWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
viewAllWindow.addGroceryList(self.groceryList.getAllIngredients())
writeDesktopButton = Button(self.IMG_DIR, "writeToDesktop", (705,80), "writeToDesktop", -1)
self.buttonGroup.add(writeDesktopButton)
def setUpRecipeAdder(self):
ingParser = IngredientParser()#self.dbm.loadParserDataFields())
recipeAdderWindow = RecipeReciever("addRecipePage",self.IMG_DIR, ingParser)
self.windowGroup.add(recipeAdderWindow)
backButton = Button(self.IMG_DIR, "backButton", (705,30), "menu", -1)
self.buttonGroup.add(backButton)
"""def setUpSearch(self):
self.windowGroup.add(TextBox(
#def setUpSearchTextBox(self):"""
def doPaste(self):
if self.state == "addRecipe":
(self.windowGroup.sprites())[0].recieveClipboardPaste(pyperclip.paste())
def attemptScroll(self, dy):
for sprite in self.windowGroup.sprites():
sprite.scroll(dy)
def handleLeftMouseClick(self, xy):
for button in self.buttonGroup.sprites():
if button.getRect().collidepoint(xy):
## stupid organization leads to hacky solutions...
# in groceryList viewer, the writeToDesktop button must be stored in the main
# class. So thats whats going on here, we call writeToDesktop
# in the scrollable window and grab the grocery list there and send that to
# dbm to write it to desktop
if button.getIdentity() == "writeToDesktop":
theString = self.windowGroup.sprites()[0].writeToDesktop()
#print
#print
#print theString
self.dbm.writeStringToDesktop(self.windowGroup.sprites()[0].writeToDesktop(), "Grocery List")
self.state = "menu"
self.stateChanged = True
#print "got here!"
return
## we want to store the state of the stuff people are looking at
# whether that is a grocery list they have increased or recipes they have added to cart
# we call the "grabState()" method of the scrollableWindow to get the information
#### keep in mind, this is the previous state
# so if self.state == "browseAll" it means we are coming from browseAll state
# to the menu
if self.state == "browseAll":
## this one is tricky. We need to store a list of toggled rows, and then
# if the user goes back to the viewAllBrowser we need to call "updateState()"
# with this list, to ensure those buttons are toggled to reflect that they are
# still in the groceryList
# keep in mind this is a list of the names of the recipes that are already added
# so we will need to search for them in "updateState()"
allWindows = self.windowGroup.sprites()
if allWindows:
self.toggledRecipeNames = allWindows[0].grabState()
elif self.state == "viewGroceryList":
## this one is simple, we just grabState() and store the returns in self.groceryList
# all the changes the user has made will be in the new list
# and new changes will happen to that list
allWindows = self.windowGroup.sprites()
if allWindows:
self.groceryList.empty()
self.groceryList.addIngredientList(allWindows[0].grabState())
self.state = button.getIdentity()
self.stateChanged = True
command = None
if self.state == "browseAll" or self.state == "deleteRecipe":
for scrollableWindow in self.windowGroup.sprites():
if scrollableWindow.getRect().collidepoint(xy):
command = scrollableWindow.isClicked(xy)
break
if not command == None:
## command is a string, meaning there is a change of state
# from the button press
#print "command recieved!"
#print " ", command
if isinstance(command, str):
self.state = command
self.stateChanged = True
#print "this thing"
else:
if len(command) == 2:
#print "entered here"
#print "command[0]:", command[0]
if command[0] == "expand":
recipeInfo = self.dbm.loadRecipe(command[1]).toReadableString()
scrollableWindow.addTextBlock(command[1], recipeInfo)
elif command[0] == "addToGroceryList":
self.groceryList.addRecipe(self.dbm.loadRecipe(command[1]))
elif command[0] == "removeFromGroceryList":
self.groceryList.removeRecipe(self.dbm.loadRecipe(command[1]))
elif command[0] == "writeToDesktop":
#print "got into this"
self.dbm.writeRecipeToDesktop(command[1])
if command[0] == "delete":
#print "got here"
self.dbm.deleteRecipe(command[1])
elif self.state == "menu" or self.state=="prestart":
for sprite in self.buttonGroup.sprites():
if sprite.rect.collidepoint(xy):
parseID = sprite.getIdentity().split()
# no extra info, just an ID for the new state
# if this is not true there is something wrong
if len(parseID) == 1:
spriteID = parseID[0]
if not spriteID == self.state:
self.state = spriteID
self.stateChanged = True
else:
raise GUIError("button gives too much data")
elif self.state == "addRecipe":
for recipeReciever in self.windowGroup.sprites():
recipeData = recipeReciever.isClicked(xy)
if not recipeData == None:
#for k in recipeData.keys():
#print k, recipeData[k]
self.dbm.addRecipeToDataBase(Recipe.fromDictionary(recipeData))
self.state = "menu"
self.stateChanged = True
elif self.state == "viewGroceryList":
for scrollableWindow in self.windowGroup.sprites():
command = scrollableWindow.isClicked(xy)
elif self.state == "search":
## search has 2 states, the first is a text box where the user
# enters what the search ingredient is
# the second the window where the results are displayed
# we determine which state by what is in self.windowGroup.sprites()
# a TextBox is the first state, a ScrollableWindow is the second
for sprite in self.windowGroup.sprites():
pass#command = sprite.isClicked
def createMenu(self):
browseButton = Button(self.IMG_DIR, "textButton", (10,75), "browseAll", -1)
browseButton.addText("Browse All")
self.buttonGroup.add(browseButton)
#searchButton = Button(self.IMG_DIR, "textButton", (210,75), "search", -1)
#searchButton.addText("Search")
#self.buttonGroup.add(searchButton)
addRecipeButton = Button(self.IMG_DIR, "textButton", (410,75), "addRecipe", -1)
addRecipeButton.addText("Add Recipe")
self.buttonGroup.add(addRecipeButton)
deleteRecipeButton = Button(self.IMG_DIR, "textButton", (10,275), "deleteRecipe", -1)
deleteRecipeButton.addText("Delete Recipe")
self.buttonGroup.add(deleteRecipeButton)
groceryListButton = Button(self.IMG_DIR, "textButton", (210,275), "viewGroceryList", -1)
groceryListButton.addText("View Cart")
self.buttonGroup.add(groceryListButton)
exitButton = Button(self.IMG_DIR, "textButton", (410, 275), "exit", -1)
exitButton.addText("Exit")
self.buttonGroup.add(exitButton)
class ViewManager (pygame.sprite.Sprite):
def __init__ ( self, color, initial_position, size, player = None ):
"""Creates a new ViewManager object."""
#Sprite
pygame.sprite.Sprite.__init__(self)
self.image = pygame.Surface(size)
self.image.fill(color)
self.rect = self.image.get_rect()
self.rect.topleft = initial_position
#Drawable objects
if (player == None):
self.player = Character()
else: self.player = player
#Draw starting objects
#self.setup()
#Sprite Groups
self.activeObjects = Group()
self.activeBackground = Group()
self.activeAvatar = pygame.sprite.GroupSingle()
#Collision
self.collision = CollisionManager()
def setup(self):
"""Does nothing at this point."""
#self.image.blit(self.player.image, self.player.rect) #Draw player onto self
pass
def update(self):
"""Calls the update method of all active objects, checks for colisions with player."""
self.collision.update()
self.activeObjects.update()
self.activeBackground.update()
self.activeAvatar.update()
def setCurrentView ( self , view ):
"""Replaces current active objects with those of the passed view."""
if(DEBUG):print("Setting view");
self.activeBackground.empty() #Get rid of old background
self.activeObjects.empty() #Get rid of old objects
self.activeAvatar.empty() #Get rid of old Avatar
#Adds new background, objects, and avatar
self.activeBackground.add(view.background)
self.activeObjects.add(view.objects)
self.activeAvatar.add(view.avatar)
#Passes CollisionManager active objects
self.collision.setActiveObjects(self.activeObjects, self.activeAvatar)
pass
def drawView ( self ):
"""Draws sprites in the proper order for depth
1. Background
2. Objects
3. Player avatar
"""
self.activeBackground.draw(self.image)
self.activeObjects.draw(self.image)
self.activeAvatar.draw(self.image)
pass
