def run_game():
pygame.init()
m_settings = Settings()
stats = Estadisticas(m_settings)
fj.cargar_puntuacion(stats)
screen = pygame.display.set_mode((m_settings.screen_width, m_settings.screen_height)) #dibujar pantalla
nave = Nave(screen, m_settings) #Dibujar nave
balas = Group() #Un grupo es una lista con funciones añadidas
marcianitos = Group()
fj.crear_flota(m_settings, screen, nave, marcianitos)
icon = pygame.image.load("images/alien.bmp")
pygame.display.set_icon(icon)
pygame.display.set_caption("Marcianitos")
boton = Boton(m_settings, screen, "Jugar")
hud = Hud(m_settings, screen, stats)
m.musica_fondo()
while True:
fj.comprobar_eventos(m_settings, screen, nave, balas, stats, marcianitos, boton)
if stats.jugando:
nave.actualizar_posicion(m_settings)
fj.actualizar_balas(m_settings, screen, nave, marcianitos, balas, stats, hud)
fj.actualizar_flota(m_settings, stats, screen, balas, marcianitos, nave, hud)
fj.actualizar_pantalla(m_settings, screen, nave, marcianitos, balas, boton, stats, hud)
def run_game():
pygame.init() #Inicializa o jogo e cria um objeto para a tela
ai_configuracoes = Configuracoes(
) #objeto ai_configuracoes da Classe Configuracoes
tela = pygame.display.set_mode(
(ai_configuracoes.tela_width, ai_configuracoes.tela_height))
pygame.display.set_caption("Space War")
nave_espacial = Nave(ai_configuracoes,
tela) #objeto nave_espacial da classe Nave
municoes = Group() #Cria um grupo no qual serão armazenados as munições
aliens = Group() #Cria um grupo vazio para armazenar os aliens do jogo
jf.cria_frota(
ai_configuracoes, tela, nave_espacial, aliens
) #Cria uma frota de aliens (usa configurações, tela e um grupo vazio de aliens)
while True: #Inicia o laço principal do jogo
jf.check_eventos(ai_configuracoes, tela, nave_espacial,
municoes) #checa os eventos
nave_espacial.update_nave() #posicionamento da nave
jf.update_municoes(
ai_configuracoes, tela, nave_espacial, aliens,
municoes) #verifica as municoes na tela ,se houve disparo
jf.update_aliens(ai_configuracoes, aliens)
jf.update_tela(ai_configuracoes, tela, nave_espacial, aliens,
municoes) #update da tela
def __init__(self,screen,figura,bala,bomba,vida):
Nave.__init__(self,screen,figura,bala,bomba,vida)
self.leftSigueApretada = False
self.upSigueApretada = False
self.downSigueApretada = False
self.rightSigueApretada = False
self.velocidad = 12
self.vx,self.vy = 0,0
self.cnt_disparo = 0
def prep_naves(self):
"""Amostra quantas naves ainda restam"""
self.naves = Group()
for nave_num in range(self.stats.nave_left):
nave = Nave(self.ik_game)
nave.image = pygame.transform.rotate(pygame.transform.scale(
pygame.image.load(os.path.join('complemento/aventine_ship.bmp')), (50, 20)), 90)
nave.rect.x = 10 + nave_num * nave.rect.width
nave.rect.y = 10
self.naves.add(nave)
def run_game():
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.tela_larguraX, settings.tela_alturaY))
naveX_change = 0
naveY_change = 0
nave = Nave(screen)
run = True
while run:
screen.fill((settings.bg_color))
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.KEYDOWN: # 1-quando a tecla estah sendo apartada
if event.key == pygame.K_UP:
naveY_change = -settings.velocidade
if event.key == pygame.K_DOWN:
naveY_change = settings.velocidade
if event.key == pygame.K_LEFT:
naveX_change = -settings.velocidade
if event.key == pygame.K_RIGHT:
naveX_change = settings.velocidade
if event.key == pygame.K_ESCAPE or event.key == pygame.K_q:
run = False
if event.type == pygame.KEYUP:
if event.key == pygame.K_UP or event.key == pygame.K_DOWN:
naveY_change = 0
if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
naveX_change = 0
settings.naveY += naveY_change
settings.naveX += naveX_change
if settings.naveX <= 0:
settings.naveX = 0
elif settings.naveX >= 736:
settings.naveX = 736
if settings.naveY <= 0:
settings.naveY = 0
elif settings.naveY >= 535:
settings.naveY = 535
nave.colocar(settings.naveX, settings.naveY)
pygame.display.update()
def run_game():
# Inicializa o jogo e define resolução
pygame.init()
config = Settings()
tela = pygame.display.set_mode((config.screen_width, config.screen_height))
pygame.display.set_caption("Alien Invasion")
nave = Nave(tela, config)
while True:
# Laço principal do jogo
game_functions.check_events(nave)
nave.update()
game_functions.update_screen(config, tela, nave)
def initializeGL(self):
glClearColor(0.0, 0.0, 0.0, 0.0)
glShadeModel(GL_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_ALPHA_TEST)
glAlphaFunc(GL_NOTEQUAL, 0.0)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(-50.0, 50.0, -50.0, 50.0, -1, 1)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
self.myNave = Nave(self.animation_propellant_enemy, self.player_x)
self.in_scene.append(self.myNave)
self.myNave2 = Nave(self.animation_propellant_enemy, self.player2_x)
self.in_scene.append(self.myNave2)
self.imageID_back = self.loadImage("img/Background.png")
for i in range(EXPLOSION_FRAMES):
self.animation_explosion[i] = self.loadImage("img/explosion/Comp" +
str(i) + ".png")
for i in range(PROPELLANT_FRAMES):
self.animation_propellant_enemy[i] = self.loadImage(
"img/fire/Comp" + str(i) + ".png")
self.img_nave_amarela = self.loadImage("img/nave4.png")
self.img_nave_azul = self.loadImage("img/nave1.png")
self.img_nave_preta = self.loadImage("img/nave3.png")
self.img_tiro_amarelo = self.loadImage("img/nave4_pow.png")
self.img_tiro_preto = self.loadImage("img/nave3_pow.png")
self.img_tiro_azul = self.loadImage("img/nave1_pow.png")
self.img_tiro = self.loadImage("img/nave2_pow.png")
self.logo_init = self.loadImage("img/SpaceCute.png")
self.logo_end = self.loadImage("img/YouDied.png")
self.myLogo_i.load("inicio", self.logo_init, self.logo_end)
self.ornaments.append(self.myLogo_i)
self.myLogo_i.inited = True
self.myLogo_e.load("fim", self.logo_init, self.logo_end)
self.init_queue()
def __init__(self):
pygame.init()
self.conf = Configurador()
#Abre la pantalla
self.pantalla = pygame.display.set_mode(
(self.conf.ancho_pant, self.conf.largo_pant))
pygame.display.set_caption("Hola Pyschool")
self.nave = Nave(self)
self.balas = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._crear_invasores()
def run_game():
pygame.init()
ai_config = Config()
screen = pygame.display.set_mode(
(ai_config.screen_width, ai_config.screen_height))
image = ai_config.sprit_image
pygame.display.set_caption('Foguete')
nave = Nave(ai_config, screen)
while True:
gf.check_events(nave)
nave.update()
gf.update_screen(image, screen, nave)
def __init__(self,idProceso,prioridad,recurso,posX ,ventana, posY,quantum=0,nombre="ataque planeta",t=8,tr=0,):
Proceso.__init__(self,idProceso,prioridad,quantum,nombre,recurso,t,tr,ventana)
Sprite.__init__(self)
self.disparo = Nave()
self.disparo.rect.top = posY
self.disparo.rect.left = posX
self.disparo.disparada = True
def prep_naves(self):
self.naves = Group()
for numero_naves in range(self.estadisticas.naves_restantes):
nave = Nave(self.configuracion_ia, self.pantalla)
nave.rect.x = 10 + numero_naves * nave.rect.width
nave.rect.y = 10
self.naves.add(nave)
class Game:
def __init__(self):
pygame.init()
# centra la ventana en la pantalla.
os.environ['SDL_VIDEO_CENTERED'] = '3'
self.window = pygame.display.set_mode((WIDTH, HEIGHT), pygame.NOFRAME)
self.bg = pygame.image.load(os.path.join("data/image",
"space.jpg")).convert()
# cambia el icono
self.icon = pygame.image.load(
os.path.join("data/image", "asteroid.png"))
pygame.display.set_icon(self.icon)
# corre el bucle del juego
#
self.nav_img = pygame.image.load(
os.path.join("data/image", "nave2.png"))
self.nav_img = pygame.transform.scale(self.nav_img, (128, 128))
self.run()
def run(self) -> None:
"""
Bucle principal del juego.
"""
self.clock = pygame.time.Clock()
self.nave = Nave(self.nav_img, 200, 400)
while True:
self.clock.tick(40)
# - events -
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# - draw -
self.window.blit(self.bg, (0, 0))
self.nave.draw(self.window)
self.nave.update()
# - updates -
pygame.display.update()
def rodar_game():
pygame.init() #inicializa a biblioteca paygame
configuracoes = Configuracoes() #cria o objeto configuracoes
tela = pygame.display.set_mode(
(configuracoes.largura_tela,
configuracoes.altura_tela)) #configura as dimensoes da tela
pygame.display.set_caption(
"Invasão Alienígena") #adiciona um titulo a tela criada
play = Botao(configuracoes, tela, "PLAY") #criar o objeto botao para play
nave = Nave(configuracoes, tela) #criar o objeto nave
tiros = Group() #criar um grupo de tiros
aliens = Group() #criar um grupo de aliens
naves_vidas = Group() #criar um grupo de naves para vidas
tela_pontuacao = TelaPontuacao(configuracoes,
tela) #criar tela para pontuacao
fg.criar_frota_aliens(aliens, nave, configuracoes,
tela) #criar frota inicial de aliens
fg.criar_naves_vidas(naves_vidas, configuracoes,
tela) #criar as tres naves vidas
while True:
fg.checar_eventos(nave, tiros, configuracoes, tela,
play) #checa eventos do teclado
fg.atualizar_tela(configuracoes, nave, naves_vidas, tela, tiros,
aliens, play,
tela_pontuacao) #atualiza a tela para cada ciclo
if configuracoes.jogo_ativo: #condicao para jogo comecar
nave.atualizacao_nave() #atualiza a posicao da nave
fg.atualizacao_tiros(tiros) #atualiza a posicao dos tiros
tela_pontuacao.atualizacao_pontuacao()
fg.atualizar_frota(aliens, tiros, nave, naves_vidas, configuracoes,
tela) #atualiza a tela por ciclo do laco
def reestart(self):
self.reloc()
self.started = False
self.player_move_left = False
self.player_move_right = False
self.myNave = Nave(0)
self.elapsed_time_shoot = 0
self.elapsed_time_asteroide = 0
self.elapsed_time_inimigo = 0
self.in_scene = []
self.in_scene.append(self.myNave)
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/inGame.wav", self)
self.sound_inGame.play()
if self.myLogo_i.inited:
self.ornaments.remove(self.myLogo_i)
self.myLogo_i.inited = False
if self.myLogo_e.inited:
self.ornaments.remove(self.myLogo_e)
self.myLogo_e.inited = False
def run_game():
# Inicializa o pygame, as configurações e o objeto screen
pygame.init()
ai_settings = Cfg()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("invasao alien")
# Cria uma espaçonave
nave = Nave(ai_settings, screen)
disparos = Group()
# Inicializa o laço principal do jogo
while True:
# Observa eventos de teclado e de mouse
gf.check_events(ai_settings, screen, nave, disparos)
nave.update()
gf.disparos_update(disparos)
gf.update_screen(ai_settings, screen, nave, disparos)
def run(self) -> None:
"""
Bucle principal del juego.
"""
self.clock = pygame.time.Clock()
self.nave = Nave(self.nav_img, 200, 400)
while True:
self.clock.tick(40)
# - events -
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# - draw -
self.window.blit(self.bg, (0, 0))
self.nave.draw(self.window)
self.nave.update()
# - updates -
pygame.display.update()
def __init__(self):
"""Inicializa o jogo e cria os recursos"""
pygame.init()
self.configuracoes = Configuracoes()
"""Para habilitar modo Fullscreen, retire as anotações
dos três códigos abaixo e adicione observação no 'self.screen'"""
# self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
# self.configuracoes.screen_width = self.screen.get_rect().width
# self.configuracoes.screen_height = self.screen.get_rect().height
self.screen = pygame.display.set_mode(
(self.configuracoes.screen_width,
self.configuracoes.screen_height))
pygame.display.set_caption("Invasão Klingon")
# Cria uma instância para armazenar os dados do jogo
self.stats = GameStats(self)
self.placar = Placar(self)
self.placar = Placar(self)
# Músicas de fundo
self.open_music = pygame.mixer.Sound(
os.path.join("complemento/tng_open.mp3")
) # Abertura da série Star Trek: Next Generation
self.battle_music = pygame.mixer.Sound(
os.path.join(
"complemento/first_contact.mp3")) # Assimilation battle sound
# Sprites
self.nave = Nave(self)
self.tiros = pygame.sprite.Group()
self.klingons = pygame.sprite.Group()
self._criar_frota()
# Botão de iniciar
self.play_botao = Botao(self, "Iniciar")
# Icon
self.icon = pygame.transform.scale(
pygame.image.load(os.path.join("complemento/klingon_icon.png")),
(35, 35))
pygame.display.set_icon(self.icon)
def correr_juego():
pygame.init()
configuracion_ia = Configuracion()
pantalla = pygame.display.set_mode(
(configuracion_ia.ancho_pantalla, configuracion_ia.alto_pantalla))
pygame.display.set_caption("Invasion Alien")
boton_jugar = Boton(configuracion_ia, pantalla , "Jugar!")
estadisticas = EstadisticasJuego(configuracion_ia)
tp = TablaPuntaje(configuracion_ia, pantalla, estadisticas)
nave = Nave(configuracion_ia, pantalla)
balas = Group()
aliens = Group()
fj.crear_flota(configuracion_ia, pantalla, nave, aliens)
while True:
fj.chequear_events(configuracion_ia, pantalla, estadisticas, tp, boton_jugar, nave, aliens, balas)
if estadisticas.juego_activo:
nave.actualizar()
fj.actualizar_balas(configuracion_ia,pantalla, estadisticas, tp, nave, aliens, balas)
fj.actualizar_aliens(configuracion_ia, estadisticas, tp, pantalla, nave, aliens, balas)
fj.actualizar_pantalla(configuracion_ia, pantalla, estadisticas, tp, nave, aliens, balas, boton_jugar)
def criarNave(self, idModelo, nick):
orientacaoInicial = sample(
[0, 90, 180, 270],
1)[0] #escolhe uma direcao aleatoria para comecar
posicaoInicial = [randint(0, 600), randint(0, 600)
] #escolhe uma posicao aleatoria para comecar a nave
velocidade = self.__modelos[idModelo].getVelocidadePadrao()
nave = Nave(orientacaoInicial, posicaoInicial, velocidade, idModelo,
self.__modelosTiroPadrao[idModelo], nick,
self.__modelos[idModelo].getGp())
print("id nave criado: ", nave.getId())
self.__naves[nave.getId()] = nave
return [nave.getId(), nave.getOrientacao(), nave.getPosicao()]
def reestart(self):
self.reloc()
self.started = False
self.in_scene = []
self.player_x = 0
self.player2_x = 20
self.myNave = Nave(self.animation_propellant_enemy, self.player_x)
self.myNave2 = Nave(self.animation_propellant_enemy,
self.player_x + 20)
self.elapsed_time_shoot = 0
self.elapsed_time_asteroide = 0
self.elapsed_time_inimigo = 0
self.hack = False
self.in_scene.append(self.myNave)
self.in_scene.append(self.myNave2)
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/inGame.wav", self)
self.sound_inGame.play()
if self.myLogo_i.inited:
self.ornaments.remove(self.myLogo_i)
self.myLogo_i.inited = False
if self.myLogo_e.inited:
self.ornaments.remove(self.myLogo_e)
self.myLogo_e.inited = False
class main(QtWidgets.QOpenGLWidget):
########### INITIALIZE AND CREATE VAR ##################
def __init__(self, parent):
QtWidgets.QOpenGLWidget.__init__(self, parent)
self.started = False
self.imageID_back = None
self.in_scene = []
self.ornaments = []
self.moveSettings()
self.player_x = 0
self.player2_x = 20
self.elapsed_time_shoot = 0
self.elapsed_time_asteroide = 0
self.elapsed_time_inimigo = 0
self.elapsed_time_flower = 500000000000 / 2
self.elapsed_time_planet = 920000000000 / 3
self.elapsed_time_stars = 0
self.hack = False
########## SOUNDS ##################
self.sound_laser = QSound("sound/laser.wav", self)
self.sound_laser_enemy = QSound("sound/laserenemy.wav", self)
self.sound_explosion = QSound("sound/explos.wav", self)
self.sound_1000pts = QSound("sound/1000pts.wav", self)
self.sound_inGame = QSound("sound/startScene.wav", self)
self.sound_death = QSound("sound/nooo.wav", self)
########### LISTS OBJECTS ##################
self.enemy_queue = Queue_rotative()
self.asteroid_queue = Queue_rotative()
self.bullets_queue = Queue_rotative()
self.flowers_queue = Queue_rotative()
self.planets_queue = Queue_rotative()
# self.stars_queue = Queue_rotative()
self.explosion_queue = Queue_rotative()
self.propellant_queue = Queue_rotative()
self.animation_explosion = [None for i in range(EXPLOSION_FRAMES)]
self.animation_propellant_enemy = [
None for i in range(PROPELLANT_FRAMES)
]
self.img_nave_azul = None
self.img_nave_amarela = None
self.img_nave_preta = None
self.img_tiro_azul = None
self.img_tiro_preto = None
self.img_tiro_amarelo = None
self.img_tiro = None
self.logo_init = None
self.logo_end = None
self.myLogo_i = Logo()
self.myLogo_e = Logo()
self.myNave = None
self.myNave2 = None
def init_queue(self):
for i in range(10):
new = Enemy()
self.enemy_queue.push(new)
for i in range(10):
new = Asteroide()
self.asteroid_queue.push(new)
for i in range(50):
new = Shoot()
self.bullets_queue.push(new)
for i in range(3):
new = Flor()
self.flowers_queue.push(new)
for i in range(5):
new = Planeta()
self.planets_queue.push(new)
for i in range(21):
new = Explode()
self.explosion_queue.push(new)
for i in range(11):
new = Propellant()
self.propellant_queue.push(new)
########### KEYBOARD PLAYER FUNC ##################
def moveSettings(self):
self.shortcut_left = QShortcut(QtCore.Qt.Key_A, self)
self.shortcut_left.activated.connect(self.move_left)
self.shortcut_right = QShortcut(QtCore.Qt.Key_D, self)
self.shortcut_right.activated.connect(self.move_right)
self.shortcut_left_shoot = QShortcut(QtCore.Qt.Key_Q, self)
self.shortcut_left_shoot.activated.connect(self.move_left_and_shoot)
self.shortcut_right_shoot = QShortcut(QtCore.Qt.Key_E, self)
self.shortcut_right_shoot.activated.connect(self.move_right_and_shoot)
self.shortcut_up = QShortcut(QtCore.Qt.Key_W, self)
self.shortcut_up.activated.connect(self.player_shoot)
self.shortcut_hack = QShortcut(QtCore.Qt.Key_T, self)
self.shortcut_hack.activated.connect(self.active_hack)
self.shortcut_left = QShortcut(QtCore.Qt.Key_J, self)
self.shortcut_left.activated.connect(self.move2_left)
self.shortcut_right = QShortcut(QtCore.Qt.Key_L, self)
self.shortcut_right.activated.connect(self.move2_right)
self.shortcut_up = QShortcut(QtCore.Qt.Key_I, self)
self.shortcut_up.activated.connect(self.player2_shoot)
########### PREPARING THE SCENE ##################
def initializeGL(self):
glClearColor(0.0, 0.0, 0.0, 0.0)
glShadeModel(GL_SMOOTH)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_ALPHA_TEST)
glAlphaFunc(GL_NOTEQUAL, 0.0)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(-50.0, 50.0, -50.0, 50.0, -1, 1)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
self.myNave = Nave(self.animation_propellant_enemy, self.player_x)
self.in_scene.append(self.myNave)
self.myNave2 = Nave(self.animation_propellant_enemy, self.player2_x)
self.in_scene.append(self.myNave2)
self.imageID_back = self.loadImage("img/Background.png")
for i in range(EXPLOSION_FRAMES):
self.animation_explosion[i] = self.loadImage("img/explosion/Comp" +
str(i) + ".png")
for i in range(PROPELLANT_FRAMES):
self.animation_propellant_enemy[i] = self.loadImage(
"img/fire/Comp" + str(i) + ".png")
self.img_nave_amarela = self.loadImage("img/nave4.png")
self.img_nave_azul = self.loadImage("img/nave1.png")
self.img_nave_preta = self.loadImage("img/nave3.png")
self.img_tiro_amarelo = self.loadImage("img/nave4_pow.png")
self.img_tiro_preto = self.loadImage("img/nave3_pow.png")
self.img_tiro_azul = self.loadImage("img/nave1_pow.png")
self.img_tiro = self.loadImage("img/nave2_pow.png")
self.logo_init = self.loadImage("img/SpaceCute.png")
self.logo_end = self.loadImage("img/YouDied.png")
self.myLogo_i.load("inicio", self.logo_init, self.logo_end)
self.ornaments.append(self.myLogo_i)
self.myLogo_i.inited = True
self.myLogo_e.load("fim", self.logo_init, self.logo_end)
self.init_queue()
def loadImage(self, path):
im = Image.open(path)
ix, iy, image = im.size[0], im.size[1], im.tobytes()
ID = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, ID)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image)
return ID
########### PAINT FUNC ##################
def paintGL(self):
self.check_end_backm()
self.update()
if self.myNave.dead:
self.started = False
glClear(GL_COLOR_BUFFER_BIT)
glLoadIdentity()
########### DRAW BACKGROUND ##################
glColor3f(1.0, 1.0, 1.0)
glDisable(GL_LIGHTING)
glEnable(GL_TEXTURE_2D)
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE)
glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glBindTexture(GL_TEXTURE_2D, self.imageID_back)
glPushMatrix()
glBegin(GL_QUADS)
glTexCoord2f(0, 1)
glVertex3f(50, -50, 1)
glTexCoord2f(1, 1)
glVertex3f(-50, -50, 1)
glTexCoord2f(1, 0)
glVertex3f(-50, 50, 1)
glTexCoord2f(0, 0)
glVertex3f(50, 50, 1)
glEnd()
glPopMatrix()
glDisable(GL_TEXTURE_2D)
self.update_time()
self.spawn_flowers()
self.spawn_planets()
self.spawn_stars()
########### DRAW ORNAMENTS ##################
for obj in self.ornaments:
if not obj == None:
if obj.dead:
if isinstance(obj, Flor):
self.flowers_queue.push(obj)
self.ornaments.remove(obj)
elif isinstance(obj, Planeta):
self.planets_queue.push(obj)
self.ornaments.remove(obj)
elif isinstance(obj, Star):
self.ornaments.remove(obj)
obj.draw()
obj.act()
obj.check_dead()
# print(self.bullets_queue.tam())
########### VERIFY IF THE GAME HAS STARTED ##################
if (not self.started):
return
########### DRAW SCENE ##################
for obj in self.in_scene:
if not obj == None:
if obj.dead:
if isinstance(obj, Enemy):
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion,
obj.move_x + obj.position_x,
obj.move_y + 6, "enemy")
self.in_scene.append(new_explosion)
self.enemy_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Asteroide):
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion,
obj.move_x + obj.position_x,
obj.move_y + 5, "enemy")
self.in_scene.append(new_explosion)
self.asteroid_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Shoot):
self.bullets_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Explode):
obj.dead = False
self.explosion_queue.push(obj)
self.in_scene.remove(obj)
obj.draw()
obj.act()
obj.check_dead()
########### COLLISION CHECK ##################
for obj_A in self.in_scene:
if isinstance(obj_A, Asteroide):
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Nave) and self.collide(
obj_B, obj_A):
# obj_B.dead = True
ui.down_life()
obj_A.dead = True
elif isinstance(obj_B, Shoot) and self.collide(
obj_B, obj_A):
if not obj_B.is_enemy:
obj_A.dead = True
if not self.hack:
obj_B.dead = True
self.sound_explosion.play()
ui.up_point(10)
if ui.score % 1000 == 0:
self.sound_1000pts.play()
elif isinstance(obj_A, Enemy):
obj_A.elapsed_shoot_time += time()
if obj_A.elapsed_shoot_time >= SHOOT_TIME_ENEMY:
if obj_A.nave_type == 0:
self.create_shoot(obj_A.move_x + obj_A.position_x,
obj_A.move_y, obj_A.move_y + 6, True,
obj_A.nave_type, obj_A.shoot_type,
self.img_tiro_azul)
elif obj_A.nave_type == 1:
self.create_shoot(obj_A.move_x + obj_A.position_x,
obj_A.move_y, obj_A.move_y + 6, True,
obj_A.nave_type, obj_A.shoot_type,
self.img_tiro_amarelo)
elif obj_A.nave_type == 2:
self.create_shoot(obj_A.move_x + obj_A.position_x,
obj_A.move_y, obj_A.move_y + 6, True,
obj_A.nave_type, obj_A.shoot_type,
self.img_tiro_preto)
obj_A.elapsed_shoot_time = 0
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Nave) and self.collide(
obj_B, obj_A):
# obj_B.dead = True
ui.down_life()
obj_A.dead = True
elif isinstance(obj_B, Shoot) and self.collide(
obj_B, obj_A):
if not obj_B.is_enemy:
obj_A.dead = True
if self.hack:
obj_B.dead = False
else:
obj_B.dead = True
self.sound_explosion.play()
ui.up_point(10)
if ui.score % 1000 == 0:
self.sound_1000pts.play()
elif isinstance(obj_A, Shoot):
if obj_A.is_enemy:
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Nave) and self.collide(
obj_B, obj_A):
# obj_B.dead = True
ui.down_life()
obj_A.dead = True
self.spawn_asteroide()
self.spawn_inimigos()
self.update()
def check_end_backm(self):
if self.sound_inGame.isFinished():
self.sound_inGame.play()
def update_time(self):
self.elapsed_time_shoot += time()
self.elapsed_time_asteroide += time()
self.elapsed_time_inimigo += time()
self.elapsed_time_flower += time()
self.elapsed_time_planet += time()
self.elapsed_time_stars += time()
def spawn_stars(self):
if self.elapsed_time_stars >= SPANW_TIME_STARS:
position = randint(-49, 49)
scale = self.rand_tam_star()
new_star = Star(position, scale)
self.ornaments.append(new_star)
self.elapsed_time_stars = 0
def spawn_planets(self):
if self.elapsed_time_planet >= SPANW_TIME_PLANET:
position = randint(-50, 50)
scale = self.rand_tam()
new_planet = self.planets_queue.pop()
new_planet.load(position, scale)
self.ornaments.append(new_planet)
self.elapsed_time_planet = 0
def rand_tam(self):
return float(str(randint(0, 2)) + "." + str(randint(1, 5)))
def rand_tam_star(self):
return float("0." + str(randint(1, 3)))
def spawn_flowers(self):
if self.elapsed_time_flower >= SPANW_TIME_FLOWER:
position = randint(-50, 50)
new_flower = self.flowers_queue.pop()
new_flower.load(position)
self.ornaments.append(new_flower)
self.elapsed_time_flower = 0
########### SPAWNING ASTEROIDE FUNCS #################
def spawn_asteroide(self):
if self.elapsed_time_asteroide >= SPANW_TIME:
new_aste = self.asteroid_queue.pop()
new_aste.load(randint(-49, 43))
self.in_scene.append(new_aste)
self.elapsed_time_asteroide = 0
########### SPAWNING ASTEROIDE FUNCS #################
def spawn_inimigos(self):
if self.elapsed_time_inimigo >= SPANW_TIME_ENEMY:
self.create_inimigos()
def create_inimigos(self):
new_inimigo = self.enemy_queue.pop()
new_inimigo.load(randint(-49, 43), self.animation_propellant_enemy,
self.img_nave_azul, self.img_nave_amarela,
self.img_nave_preta)
self.in_scene.append(new_inimigo)
self.elapsed_time_inimigo = 0
########### MOVING PLAYER FUNCS #################
def move_left(self):
if self.myNave.move_x + self.myNave.position_x - 4.0 >= -47:
self.myNave.move_left()
self.player_x -= 3
def move_left_and_shoot(self):
if self.myNave.move_x + self.myNave.position_x - 4.0 >= -47:
self.myNave.move_left()
self.player_x -= 3
self.create_shoot(self.player_x)
def move_right(self):
if self.myNave.move_x + self.myNave.position_x + 4.0 <= 47:
self.myNave.move_right()
self.player_x += 3
def move_right_and_shoot(self):
if self.myNave.move_x + self.myNave.position_x + 4.0 <= 47:
self.myNave.move_right()
self.player_x += 3
self.create_shoot(self.player_x)
#############NEWS##############################
def move2_left(self):
if self.myNave2.move_x + self.myNave2.position_x - 4.0 >= -47:
self.myNave2.move_left()
self.player2_x -= 3
def move2_right(self):
if self.myNave2.move_x + self.myNave2.position_x + 4.0 <= 47:
self.myNave2.move_right()
self.player2_x += 3
########### SHOOT PLAYER FUNC ##################
########### CREATE THE BULLET ##################
def player_shoot(self):
self.create_shoot(self.player_x)
def player2_shoot(self):
self.create_shoot(self.player2_x)
def create_shoot(self,
position,
position_y=None,
position_y_2=None,
is_enemy=False,
type="player",
qtd=None,
tiro_respectivo=None):
if is_enemy:
if qtd == 1:
new_shoot = self.bullets_queue.pop()
new_shoot.load(tiro_respectivo, position, position_y,
position_y_2, True, type)
self.in_scene.append(new_shoot)
elif qtd == 2:
new_shoot = self.bullets_queue.pop()
new_shoot.load(tiro_respectivo, position - 2.5, position_y,
position_y_2, True, type)
new_shoot2 = self.bullets_queue.pop()
new_shoot2.load(tiro_respectivo, position + 2.5, position_y,
position_y_2, True, type)
self.in_scene.append(new_shoot)
self.in_scene.append(new_shoot2)
elif qtd == 3:
new_shoot = self.bullets_queue.pop()
new_shoot.load(tiro_respectivo, position - 5, position_y,
position_y_2, True, type)
new_shoot2 = self.bullets_queue.pop()
new_shoot2.load(tiro_respectivo, position, position_y,
position_y_2, True, type)
new_shoot3 = self.bullets_queue.pop()
new_shoot3.load(tiro_respectivo, position + 5, position_y,
position_y_2, True, type)
self.in_scene.append(new_shoot)
self.in_scene.append(new_shoot2)
self.in_scene.append(new_shoot3)
self.sound_laser_enemy.play()
return
if self.elapsed_time_shoot >= SHOOT_TIME:
if self.hack:
new_shoot = self.bullets_queue.pop()
new_shoot.load(self.img_tiro, position + 5, -46.0, -40.0,
False, 1)
new_shoot2 = self.bullets_queue.pop()
new_shoot2.load(self.img_tiro, position - 5, -46.0, -40.0,
False, 1)
new_shoot3 = self.bullets_queue.pop()
new_shoot3.load(self.img_tiro, position, -46.0, -40.0, False,
1)
self.in_scene.append(new_shoot)
self.in_scene.append(new_shoot2)
self.in_scene.append(new_shoot3)
else:
new_shoot = self.bullets_queue.pop()
new_shoot.load(self.img_tiro, position, -46.0, -40.0, False, 1)
self.in_scene.append(new_shoot)
self.elapsed_time_shoot = 0
self.sound_laser.play()
########### COLISION CHECK FUNC ##################
def collide(self, A, B):
A_colliding_B_in_x = (A.get_x()[1] >= B.get_x()[0]
and A.get_x()[1] <= B.get_x()[1])
#or
B_colliding_A_in_x = (B.get_x()[1] >= A.get_x()[0]
and B.get_x()[1] <= A.get_x()[1])
A_colliding_B_in_y = (A.get_y()[1] >= B.get_y()[0]
and A.get_y()[1] <= B.get_y()[1])
#or
B_colliding_A_in_y = (B.get_y()[1] >= A.get_y()[0]
and B.get_y()[1] <= A.get_y()[1])
return (A_colliding_B_in_x or B_colliding_A_in_x) and \
(A_colliding_B_in_y or B_colliding_A_in_y)
def active_hack(self):
self.hack = not self.hack
def reestart(self):
self.reloc()
self.started = False
self.in_scene = []
self.player_x = 0
self.player2_x = 20
self.myNave = Nave(self.animation_propellant_enemy, self.player_x)
self.myNave2 = Nave(self.animation_propellant_enemy,
self.player_x + 20)
self.elapsed_time_shoot = 0
self.elapsed_time_asteroide = 0
self.elapsed_time_inimigo = 0
self.hack = False
self.in_scene.append(self.myNave)
self.in_scene.append(self.myNave2)
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/inGame.wav", self)
self.sound_inGame.play()
if self.myLogo_i.inited:
self.ornaments.remove(self.myLogo_i)
self.myLogo_i.inited = False
if self.myLogo_e.inited:
self.ornaments.remove(self.myLogo_e)
self.myLogo_e.inited = False
def reloc(self):
for obj in self.in_scene:
if isinstance(obj, Enemy):
self.enemy_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Asteroide):
self.asteroid_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Shoot):
self.bullets_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Explode):
self.explosion_queue.push(obj)
self.in_scene.remove(obj)
for obj in self.ornaments:
if isinstance(obj, Flor):
self.flowers_queue.push(obj)
self.ornaments.remove(obj)
elif isinstance(obj, Planeta):
self.planets_queue.push(obj)
self.ornaments.remove(obj)
def stop(self):
self.reloc()
self.started = False
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/startScene.wav", self)
self.sound_inGame.play()
self.in_scene = []
self.ornaments.append(self.myLogo_i)
if self.myLogo_e.inited:
self.ornaments.remove(self.myLogo_e)
self.myLogo_e.inited = False
self.myLogo_i.inited = True
def dead(self):
self.myNave.dead = True
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/gameOver.wav", self)
self.sound_death.play()
if self.sound_death.isFinished():
self.sound_inGame.play()
self.ornaments.append(self.myLogo_e)
self.myLogo_e.inited = True
def run():
""" Inicio del juego y crea el screen del juego """
print(platform.python_version()) #Ver version python
#pygame.init()
#Alternativa al init para ganar velocidad
pygame.display.init()
pygame.font.init()
configuracion = Configuracion() #Configuracion inicial del juego
#Lee la configuracion de pantalla
pantalla = pygame.display.set_mode(
(configuracion.ancho_pantalla, configuracion.alto_pantalla))
pygame.display.set_caption(configuracion.nombre) #Nombre del juego
#Crea una instancia de una nave
nave = Nave(configuracion, pantalla)
#Crea una instancia de un marciano
#marciano=Marciano(configuracion,pantalla)
#Creo la flota de marcianos
marcianos = Group()
#Crea la flota de marcianos
func.crear_flota(configuracion, pantalla, nave, marcianos)
#Guarda los disparos en un grupo de pygame.sprite
disparos = Group()
#Guarda los disparos marcianos en un grupo de pygame.sprite
disparosM = Group()
#puntuaciones inicializa puntuaciones , n naves etc
marcador = Marcador(configuracion)
#Informacion de las puntuaciones , marcadores
informacion = Informaciones(configuracion, pantalla, marcador)
#Crea un boton de play
boton = Boton(configuracion, pantalla, "Juega")
#Crea un bunker
bunkers = pygame.sprite.Group()
func.crear_bunkers(configuracion, pantalla, bunkers)
#Sonidos juego
sonidos = Sonidos()
#Bucle principal
while True:
sleep(0.01) #CPU usage
#Mira eventos de teclado o raton
func.analiza_eventos(configuracion, pantalla, marcador, boton, nave,
disparos, sonidos)
if marcador.juego_activo: #Juego activo ?Todas las vidas ?
#Dibuja la nave del jugador
nave.actualiza()
#Actualiza TODOS los disparo en el GROUP pero es un disparo
func.actualiza_disparos(
configuracion, marcador, pantalla, nave, marcianos, disparos,
bunkers, sonidos) #Este update() esta en la clase disparo
#Actualiza si un marciano ha disparado , falta mostrarlo
func.actualiza_marcianos(configuracion, marcador, pantalla, nave,
marcianos, disparos, disparosM, bunkers,
sonidos)
#Actualiza disparos Marcianos
func.actualiza_disparosMarcianos(
configuracion, marcador, pantalla, bunkers, nave, marcianos,
disparosM, sonidos) #Este update() esta en la clase disparo
func.actualiza_pantalla(configuracion, pantalla, informacion, marcador,
nave, marcianos, disparos, disparosM, boton,
bunkers)
#Muestra en pantalla
pygame.display.flip()
# coding=utf-8
from cao import Cao
from pessoas.pessoa import Pessoa
from pessoas.jedi import Jedi, SabreDeLuz
from pessoas.sith import Sith
from nave import Nave
# Crie uma classe Cachorro, que não herde de ninguém e adicione a tripulação da
# nave da questão anterior, e faça com que a tripulação durma. (Duck Typing)
leia = Pessoa("Princesa Leia", 27)
luke = Jedi("Luke Skywalker", 27, SabreDeLuz("Azul", "medio"))
vader = Sith("Dart Vader", 46, SabreDeLuz("Vermelho", "medio"))
cao = Cao()
nave = Nave("X-Wing", [leia, luke, vader, cao])
nave.tripulacao_dormir()
def criar_naves_vidas(naves_vidas, configuracoes, tela):
for i in range(configuracoes.limite_vida):
nova_nave_vida = Nave(configuracoes, tela)
nova_nave_vida.rect.top = nova_nave_vida.tela_rect.top
nova_nave_vida.rect.x = nova_nave_vida.rect.width * i
naves_vidas.add(nova_nave_vida)
def __init__(self,screen,figura,bala,bomba,vida):
Nave.__init__(self,screen,figura,bala,bomba,vida)
"""Exercicio com pygame."""
import pygame
from estrela import Estrela
import random
from nave import Nave
estrelas = []
rastros = []
num_estrelas = 300
num_rastros = 5
vel_mult = 2
nave = Nave()
rastrocontrol = Nave()
nave_espacial = pygame.image.load("./imgs/nave.png")
GREY = (128, 128, 128)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
def criacao(param):
"""Metodo de criacao de estrela."""
if param == 0:
x = random.randint(0, 800)
elif param == 1:
x = 800
y = random.randint(0, 600)
vel = random.randint(1, 3)
estrela = Estrela()
def instancia_nave():
"""Instancia uma nave."""
nave = Nave()
nave.set_x = 100
nave.set_y = 100
class InvasaoKlingon:
"""Class para lidar com os comportamentos do jogo"""
def __init__(self):
"""Inicializa o jogo e cria os recursos"""
pygame.init()
self.configuracoes = Configuracoes()
"""Para habilitar modo Fullscreen, retire as anotações
dos três códigos abaixo e adicione observação no 'self.screen'"""
# self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
# self.configuracoes.screen_width = self.screen.get_rect().width
# self.configuracoes.screen_height = self.screen.get_rect().height
self.screen = pygame.display.set_mode(
(self.configuracoes.screen_width,
self.configuracoes.screen_height))
pygame.display.set_caption("Invasão Klingon")
# Cria uma instância para armazenar os dados do jogo
self.stats = GameStats(self)
self.placar = Placar(self)
self.placar = Placar(self)
# Músicas de fundo
self.open_music = pygame.mixer.Sound(
os.path.join("complemento/tng_open.mp3")
) # Abertura da série Star Trek: Next Generation
self.battle_music = pygame.mixer.Sound(
os.path.join(
"complemento/first_contact.mp3")) # Assimilation battle sound
# Sprites
self.nave = Nave(self)
self.tiros = pygame.sprite.Group()
self.klingons = pygame.sprite.Group()
self._criar_frota()
# Botão de iniciar
self.play_botao = Botao(self, "Iniciar")
# Icon
self.icon = pygame.transform.scale(
pygame.image.load(os.path.join("complemento/klingon_icon.png")),
(35, 35))
pygame.display.set_icon(self.icon)
def run_game(self):
"""Inicia o loop principal do jogo"""
while True:
self._check_events()
self.open_music.play(loops=-1)
self.open_music.set_volume(0.1)
if self.stats.game_active:
self.nave.update()
self.open_music.stop()
if self.open_music.stop:
self.battle_music.play(loops=-1)
self._update_tiros()
self._update_klingons()
self._update_screen()
def _check_events(self):
"""Notar o uso do teclado e do mouse"""
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 and self.stats.game_active is False:
mouse_pos = pygame.mouse.get_pos()
self._check_iniciar_botao(mouse_pos)
pygame.mixer.Channel(2).play(
pygame.mixer.Sound(
os.path.join("complemento/computerbeep_10.mp3")))
def _check_iniciar_botao(self, mouse_pos):
"""Inicia um novo jogo quando o usuário clicar no botão"""
click_botao = self.play_botao.rect.collidepoint(mouse_pos)
if click_botao and not self.stats.game_active:
# Reset as configs do jogo
self.configuracoes.inicializar_dinamica_configs()
# Reset os stats do jogo
self.stats.reset_stats()
self.stats.game_active = True
self.placar.prep_placar()
self.placar.prep_level()
self.placar.prep_naves()
# Retira os aliens e disparos da partida antiga
self.klingons.empty()
self.tiros.empty()
# Cria uma nova frota e centraliza a nave
self._criar_frota()
self.nave.center_nave()
# Esconder o cursor do mouse
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""Responde as teclas"""
if event.key == pygame.K_RIGHT:
# Move a nave para a direita
self.nave.moving_right = True
elif event.key == pygame.K_LEFT:
self.nave.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_p:
self._iniciar_jogo()
pygame.mixer.Channel(2).play(
pygame.mixer.Sound("complemento/computerbeep_10.mp3"))
elif event.key == pygame.K_SPACE and self.stats.game_active is True:
self._dispara_tiro()
def _iniciar_jogo(self):
# Reset as configs do jogo
self.configuracoes.inicializar_dinamica_configs()
# Reset os stats do jogo
self.stats.reset_stats()
self.stats.game_active = True
self.placar.prep_placar()
def _check_keyup_events(self, event):
"""Responde a ausência de interação com o teclado"""
if event.key == pygame.K_RIGHT:
self.nave.moving_right = False
elif event.key == pygame.K_LEFT:
self.nave.moving_left = False
def _dispara_tiro(self):
"""Cria um novo disparo e adiciona esse tiro em uma lista"""
if len(self.tiros) < self.configuracoes.tiros_permitidos:
novo_disparo = Tiro(self)
self.tiros.add(novo_disparo)
pygame.mixer.Channel(1).play(
pygame.mixer.Sound(os.path.join("complemento/torp.mp3")))
pygame.mixer.Channel(1).set_volume(0.35)
def _update_tiros(self):
"""Atualiza a posição dos disparos e se deleta os antigos"""
# Atualiza a posição
self.tiros.update()
# Deleta os tiros após sairem da tela
for tiro in self.tiros.copy():
if tiro.rect.bottom <= 0:
self.tiros.remove(tiro)
self._check_colisao_disparo()
def _check_colisao_disparo(self):
# Checar se algum disparo atingiu uma nave inimiga
# Se sim, retirar a nave klingon da tela
colisao = pygame.sprite.groupcollide(self.tiros, self.klingons, True,
True)
if colisao:
for klingon in colisao.values():
self.stats.score += self.configuracoes.klingon_points * len(
klingon)
self.placar.prep_placar()
self.placar.check_high_score()
if not self.klingons:
# Destroi os tiros existentes e cria uma nova tropa
self.tiros.empty()
self._criar_frota()
self.configuracoes.aumentar_vel()
# Aumenta o nível
self.stats.level += 1
self.placar.prep_level()
def _update_klingons(self):
"""Atualiza a posição de todas as naves Klingons"""
self._check_fleet_edges()
self.klingons.update()
# Colisão de naves
if pygame.sprite.spritecollideany(self.nave, self.klingons):
self._nave_hit()
# Verifica se a nave klingon atingiu o fundo da tela
self._check_klingons_bottom()
def _nave_hit(self):
"""Responde a nave caso seja atingida por uma nave klingon"""
if self.stats.nave_left > 0:
# Decrementa nave_left
self.stats.nave_left -= 1
self.placar.prep_naves()
# Se livra das naves restantes e disparos
self.klingons.empty()
self.tiros.empty()
# Cria uma nova frota de naves e centraliza a nave
self._criar_frota()
self.nave.center_nave()
# Pausa
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _criar_frota(self):
"""Cria as naves Bird of Prey"""
# Cria os Klingons e amostra a quantidade de naves em uma fileira
# O espaço entre cada nave é igual a largura de uma nave
klingon = Klingon(self)
klingon_width, klingon_height = klingon.rect.size
espaco_disp_x = self.configuracoes.screen_width - (2 * klingon_width)
numero_klingons_x = espaco_disp_x // (2 * klingon_width)
# Determina a primeira frota completa de Klingons
nave_height = self.nave.rect.height
espaco_disp_y = (self.configuracoes.screen_height -
(3 * klingon_height) - nave_height)
num_fileiras = espaco_disp_y // (2 * klingon_height)
# Cria a primeira fileira de naves
for num_fileiras in range(num_fileiras):
for quant_klingon in range(numero_klingons_x):
self._criar_klingon(quant_klingon, num_fileiras)
def _criar_klingon(self, quant_klingon, num_fileiras):
"""Cria uma nave e a posiciona em uma fileira"""
klingon = Klingon(self)
klingon_width, klingon_height = klingon.rect.size
klingon.x = klingon_width + 2 * klingon_width * quant_klingon
klingon.rect.x = klingon.x
klingon.rect.y = klingon.rect.height + 2 * klingon.rect.height * num_fileiras
self.klingons.add(klingon)
def _check_fleet_edges(self):
"""Responde apropriadamente se qualquer nave klingon atingir a borda da tela"""
for klingon in self.klingons.sprites():
if klingon.check_edges():
self._mudar_direcao_frota()
break
def _check_klingons_bottom(self):
"""Checa se alguma nave klingon atingiu o fundo da tela"""
screen_rect = self.screen.get_rect()
for klingon in self.klingons.sprites():
if klingon.rect.bottom >= screen_rect.bottom:
# Trata da mesma forma como se a nave fosse atingida
self._nave_hit()
break
def _mudar_direcao_frota(self):
"""Mudar a direção da frota inteira"""
for klingon in self.klingons.sprites():
klingon.rect.y += self.configuracoes.fleet_drop_speed
self.configuracoes.direcao_frota *= -1
def _update_screen(self):
# Redesenha a tela durante cada passada do loop
# self.screen.fill(self.configuracoes.bg_color)
self.screen.blit(self.configuracoes.background, [0, 0])
self.nave.blitme()
for tiros in self.tiros.sprites():
tiros.draw_tiro()
self.klingons.draw(self.screen)
self.placar.show_placar()
# Desenha o botão de Íniciar se o jogo estiver inativo
if not self.stats.game_active:
self.screen.blit(self.configuracoes.background, [0, 0])
self.nave.blitme()
self.play_botao.draw_botao()
self.screen.blit(self.configuracoes.logo, [270, 35])
pygame.display.flip()
# coding=utf-8
from pessoas.pessoa import Pessoa
from pessoas.jedi import Jedi, SabreDeLuz
from pessoas.sith import Sith
from nave import Nave
# Crie uma classe Nave que contenha tripulação, uma lista de Pessoas (Lembre-se
# que um jedi, um mercenário ou mesmo um sith são pessoas) e faça com que todos
# andem pela nave.
leia = Pessoa("Princesa Leia", 27)
luke = Jedi("Luke Skywalker", 27, SabreDeLuz("Azul", "medio"))
vader = Sith("Dart Vader", 46, SabreDeLuz("Vermelho", "medio"))
nave = Nave("X-Wing", [leia, luke, vader])
nave.tripulacao_andar()
class Pyschool:
""" Clase central donde correra el juego """
def __init__(self):
pygame.init()
self.conf = Configurador()
#Abre la pantalla
self.pantalla = pygame.display.set_mode(
(self.conf.ancho_pant, self.conf.largo_pant))
pygame.display.set_caption("Hola Pyschool")
self.nave = Nave(self)
self.balas = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._crear_invasores()
def run_game(self):
""" Corre un loop que correra el juego """
while True:
self._check_events()
self.nave.refrescar()
self._balas_refrescar()
self._actulizar_pant()
def _check_events(self):
""" Checa los eventos """
#Loop que observa eventos
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
#keydowns
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
self.nave.mover_derecha = True
elif event.key == pygame.K_LEFT:
self.nave.mover_izquierda = True
elif event.key == pygame.K_SPACE:
self._disparar()
#Keyups
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
self.nave.mover_derecha = False
elif event.key == pygame.K_LEFT:
self.nave.mover_izquierda = False
def _disparar(self):
if len(self.balas) < 3:
nueva_bala = Bala(self)
self.balas.add(nueva_bala)
def _balas_refrescar(self):
self.balas.update()
collisions = pygame.sprite.groupcollide(self.balas, self.aliens, True,
True)
if not self.aliens:
sleep(1.0)
self.balas.empty()
self._crear_invasores()
for bala in self.balas.copy():
if bala.rect.bottom <= 0:
self.balas.remove(bala)
def _crear_invasores(self):
alien = Alien(self)
alien_ancho, alien_alto = alien.rect.size
espacio_disponible_x = self.conf.ancho_pant
number_aliens_x = espacio_disponible_x // (2 * alien_ancho)
nave_alto = self.nave.rect.height
espacio_disponible_y = self.conf.largo_pant - (3 *
alien_alto) - nave_alto
num_filas = espacio_disponible_y // (2 * alien_alto)
for fila_num in range(num_filas):
for alien_number in range(number_aliens_x):
self._crear_alien(alien_number, fila_num)
def _crear_alien(self, alien_number, fila_num):
alien = Alien(self)
alien_ancho, alien_alto = alien.rect.size
alien.x = alien_ancho + 2 * alien_ancho * alien_number
alien.rect.x = alien.x
alien.rect.y = alien_alto + 2 * alien_alto * fila_num
self.aliens.add(alien)
def _actulizar_pant(self):
""" Actualiza las imagenes y refresca la pantalla """
self.pantalla.fill(self.conf.fondo_color)
#llama la nave
self.nave.blitme()
for bala in self.balas.sprites():
bala.dibujar()
#Aliens
self.aliens.draw(self.pantalla)
#Refresca la pantalla
pygame.display.flip()
pygame.mixer.music.load("data/música/the_field_of_dreams.mp3")
pygame.mixer.music.play(-1)
play2()
# =====================================================#
# Sounds: #
# =====================================================#
shoot = pygame.mixer.Sound("data/música/Shoot.wav")
# =====================================================#
# loop: #
# =====================================================#
nave = Nave(objectGroup)
asteroid = Asteroid(objectGroup)
gameLoop = True
gameOver = False
clock = pygame.time.Clock()
numero = 10
if __name__ == "__main__":
while gameLoop:
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
from nave import Nave
nave1 = Nave('x', 20, 10000)
nave2 = Nave('y', 30, 13000)
print (nave1.compara_vel(nave2))
print (nave2.compara_vel(nave1))
class main(QtWidgets.QOpenGLWidget):
def __init__(self, parent):
QtWidgets.QOpenGLWidget.__init__(self, parent)
self.started = False
self.imageID_back = None
self.in_scene = []
self.ornaments = []
self.elapsed_time_shoot = 0
self.elapsed_time_asteroide = 0
self.elapsed_time_inimigo = 0
self.elapsed_time_planet = 920000000000 / 3
self.elapsed_time_stars = 0
self.elapsed_time_powers = 0
self.elapsed_time_power_shoot = 0
self.elapsed_time_power_speed = 0
self.hack = False
self.speed = False
self.sound_laser = QSound("sound/laser.wav", self)
self.sound_laser_enemy = QSound("sound/laserenemy.wav", self)
self.sound_explosion = QSound("sound/explos.wav", self)
self.sound_1000pts = QSound("sound/1000pts.wav", self)
self.sound_inGame = QSound("sound/startScene.wav", self)
self.sound_death = QSound("sound/nooo.wav", self)
self.sound_power = QSound("sound/powerUp.wav", self)
self.enemy_queue = Queue_rotative()
self.asteroid_queue = Queue_rotative()
self.bullets_queue = Queue_rotative()
self.planets_queue = Queue_rotative()
self.explosion_queue = Queue_rotative()
self.propellant_queue = Queue_rotative()
self.power_queue = Queue_rotative()
self.animation_explosion = [None for i in range(EXPLOSION_FRAMES)]
self.animation_propellant_enemy = [
None for i in range(PROPELLANT_FRAMES)
]
self.img_planets = [None for i in range(10)]
self.img_nave_azul = None
self.img_nave_amarela = None
self.img_nave_preta = None
self.img_tiro_azul = None
self.img_tiro_preto = None
self.img_tiro_amarelo = None
self.img_tiro = None
self.logo_init = None
self.logo_end = None
self.power_up_vida = None
self.power_up_shoot = None
self.power_up_speed = None
self.myLogo_i = Logo()
self.myLogo_e = Logo()
self.myNave = None
# Inicializa as filas de pre carregamentos
def init_queue(self):
for i in range(20):
new = Enemy()
self.enemy_queue.push(new)
for i in range(50):
new = Asteroide()
self.asteroid_queue.push(new)
for i in range(100):
new = Shoot()
self.bullets_queue.push(new)
for i in range(10):
new = Planeta()
self.planets_queue.push(new)
for i in range(50):
new = Explode()
self.explosion_queue.push(new)
for i in range(30):
new = Propellant()
self.propellant_queue.push(new)
for i in range(20):
new = Power_up()
self.power_queue.push(new)
# Prepara a cena e carrega as texturas
def initializeGL(self):
glClearColor(0.0, 0.0, 0.0, 0.0)
glShadeModel(GL_SMOOTH)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_ALPHA_TEST)
glAlphaFunc(GL_NOTEQUAL, 0.0)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(45, 1.65, 0.1, 500)
gluLookAt(0, -100, 50, 0, 0, 0, 0, 1, 0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
self.myNave = Nave(self.animation_propellant_enemy, 0)
self.in_scene.append(self.myNave)
for i in range(EXPLOSION_FRAMES):
self.animation_explosion[i] = self.loadImage("img/explosion/Comp" +
str(i) + ".png")
for i in range(PROPELLANT_FRAMES):
self.animation_propellant_enemy[i] = self.loadImage(
"img/fire/Comp" + str(i) + ".png")
for i in range(10):
self.img_planets[i] = self.loadImage("img/planets/planeta" +
str(i) + ".png")
self.img_nave_amarela = self.loadImage("img/nave4.png")
self.img_nave_azul = self.loadImage("img/nave1.png")
self.img_nave_preta = self.loadImage("img/nave3.png")
self.img_tiro_amarelo = self.loadImage("img/nave4_pow.png")
self.img_tiro_preto = self.loadImage("img/nave3_pow.png")
self.img_tiro_azul = self.loadImage("img/nave1_pow.png")
self.img_tiro = self.loadImage("img/nave2_pow.png")
self.logo_init = self.loadImage("img/SpaceCute.png")
self.logo_end = self.loadImage("img/YouDied.png")
self.power_up_vida = self.loadImage("img/power_up_life.png")
self.power_up_shoot = self.loadImage("img/power_up_shot.png")
self.power_up_speed = self.loadImage("img/power_up_speed.png")
self.myLogo_i.load("inicio", self.logo_init, self.logo_end)
self.ornaments.append(self.myLogo_i)
self.myLogo_i.inited = True
self.myLogo_e.load("fim", self.logo_init, self.logo_end)
self.init_queue()
# Arrumando erros de frict
fix_p = self.propellant_queue.pop()
fix_p.load(self.animation_propellant_enemy, 1000, 1000, "fix")
self.ornaments.append(fix_p)
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion, 1000, 1000, "fix")
self.ornaments.append(new_explosion)
tx = 0
ambiente = [0.2, 0.2, 0.2, 1.0]
difusa = [0.7, 0.7, 0.7, 1.0]
especular = [1.0, 1.0, 1.0, 1.0]
posicao = [0.0, 3.0, 2.0, 0.0]
lmodelo_ambiente = [0.2, 0.2, 0.2, 1.0]
glLightfv(GL_LIGHT0, GL_AMBIENT, ambiente)
glLightfv(GL_LIGHT0, GL_DIFFUSE, difusa)
glLightfv(GL_LIGHT0, GL_POSITION, posicao)
glLightfv(GL_LIGHT0, GL_SPECULAR, especular)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodelo_ambiente)
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glEnable(GL_COLOR_MATERIAL)
# Funcao para carregar imagens a partir de um caminho
def loadImage(self, path):
im = Image.open(path)
ix, iy, image = im.size[0], im.size[1], im.tobytes()
ID = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, ID)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ix, iy, 0, GL_RGBA,
GL_UNSIGNED_BYTE, image)
return ID
# funcoes para acoes no teclado
# A = move para esquerda
# D = move para direita
# W = atira
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Left:
self.myNave.moving_left = True
if event.key() == QtCore.Qt.Key_A:
self.myNave.moving_left = True
if event.key() == QtCore.Qt.Key_Right:
self.myNave.moving_right = True
if event.key() == QtCore.Qt.Key_D:
self.myNave.moving_right = True
if event.key() == QtCore.Qt.Key_Space:
self.myNave.shooting = True
if event.key() == QtCore.Qt.Key_Up:
self.myNave.moving_up = True
if event.key() == QtCore.Qt.Key_W:
self.myNave.moving_up = True
if event.key() == QtCore.Qt.Key_Down:
self.myNave.moving_down = True
if event.key() == QtCore.Qt.Key_S:
self.myNave.moving_down = True
def keyReleaseEvent(self, event):
if event.key() == QtCore.Qt.Key_Left:
self.myNave.moving_left = False
if event.key() == QtCore.Qt.Key_A:
self.myNave.moving_left = False
if event.key() == QtCore.Qt.Key_Right:
self.myNave.moving_right = False
if event.key() == QtCore.Qt.Key_D:
self.myNave.moving_right = False
if event.key() == QtCore.Qt.Key_Space:
self.myNave.shooting = False
if event.key() == QtCore.Qt.Key_Up:
self.myNave.moving_up = False
if event.key() == QtCore.Qt.Key_W:
self.myNave.moving_up = False
if event.key() == QtCore.Qt.Key_Down:
self.myNave.moving_down = False
if event.key() == QtCore.Qt.Key_S:
self.myNave.moving_down = False
# Funcao de desenhar a cena
def paintGL(self):
# Checa se a musica de fundo acabou e reinicia
self.check_end_backm()
self.update()
# Se o player morreu, entao o jogo acaba
if self.myNave.dead:
self.started = False
glClear(GL_COLOR_BUFFER_BIT)
glLoadIdentity()
self.update_time()
self.spawn_planets()
self.spawn_stars()
glDisable(GL_DEPTH_TEST)
# Desenha os ornamentos ( "Flores" )
# e retira os objetos "mortos" retornando eles para a fila
for obj in self.ornaments:
if not obj == None:
if obj.dead:
if isinstance(obj, Planeta):
self.planets_queue.push(obj)
self.ornaments.remove(obj)
elif isinstance(obj, Star):
self.ornaments.remove(obj)
elif isinstance(obj, Explode):
self.explosion_queue.push(obj)
self.ornaments.remove(obj)
elif isinstance(obj, Propellant):
self.propellant_queue.push(obj)
self.ornaments.remove(obj)
obj.draw()
obj.act()
obj.check_dead()
# Verifica se o jogo foi iniciado
if not self.started:
return
glEnable(GL_DEPTH_TEST)
# Desenha a cena
# e retira os objetos mortos retornando ele para a fila
# e instancia uma explosao no lugar
for obj in self.in_scene:
if not obj == None:
if obj.dead:
if isinstance(obj, Enemy):
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion,
obj.move_x + obj.position_x,
obj.move_y + 6, "enemy")
self.in_scene.append(new_explosion)
self.enemy_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Asteroide):
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion,
obj.move_x + obj.position_x,
obj.move_y + 5, "enemy")
self.in_scene.append(new_explosion)
self.asteroid_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Shoot):
self.bullets_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Explode):
obj.dead = False
self.explosion_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Power_up):
self.power_queue.push(obj)
self.in_scene.remove(obj)
if isinstance(obj, Nave):
if obj.shooting:
self.create_shoot(obj.move_x + obj.position_x)
obj.draw()
obj.act()
obj.check_dead()
# Testa as colisoes e aplica os efeitos (ganhar pontos, ou perder vida)
for obj_A in self.in_scene:
if isinstance(obj_A, Asteroide):
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Nave) and self.collide(
obj_B, obj_A):
# ui.down_life()
obj_A.dead = True
elif isinstance(obj_B, Shoot) and self.collide(
obj_B, obj_A):
if not obj_B.is_enemy:
obj_A.dead = True
if not self.hack:
obj_B.dead = True
self.sound_explosion.play()
ui.up_point(10)
if ui.score % 1000 == 0:
self.sound_1000pts.play()
elif isinstance(obj_A, Enemy):
obj_A.elapsed_shoot_time += time()
if obj_A.elapsed_shoot_time >= SHOOT_TIME_ENEMY:
pos = [obj_A.get_x()[0] + 5, obj_A.get_y()[0] + 6, 0]
player = [
self.myNave.get_x()[0] + 5,
self.myNave.get_y()[0] - 8, 0
]
dir = [
player[0] - pos[0], player[1] - pos[1],
player[2] - pos[2]
]
angle_R = math.atan2(dir[1], pos[0])
angle = math.degrees(angle_R)
if obj_A.nave_type == 0:
self.create_shoot(obj_A.move_x + obj_A.position_x,
obj_A.move_y, obj_A.move_y + 6, True,
obj_A.nave_type, obj_A.shoot_type,
self.img_tiro_azul, angle)
elif obj_A.nave_type == 1:
self.create_shoot(obj_A.move_x + obj_A.position_x,
obj_A.move_y, obj_A.move_y + 6, True,
obj_A.nave_type, obj_A.shoot_type,
self.img_tiro_amarelo, angle)
elif obj_A.nave_type == 2:
self.create_shoot(obj_A.move_x + obj_A.position_x,
obj_A.move_y, obj_A.move_y + 6, True,
obj_A.nave_type, obj_A.shoot_type,
self.img_tiro_preto, angle)
obj_A.elapsed_shoot_time = 0
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Nave) and self.collide(
obj_B, obj_A):
# ui.down_life()
obj_A.dead = True
elif isinstance(obj_B, Shoot) and self.collide(
obj_B, obj_A):
if not obj_B.is_enemy:
obj_A.dead = True
if self.hack:
obj_B.dead = False
else:
obj_B.dead = True
self.sound_explosion.play()
ui.up_point(10)
if ui.score % 1000 == 0:
self.sound_1000pts.play()
elif isinstance(obj_A, Shoot):
if obj_A.is_enemy:
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Nave) and self.collide(
obj_B, obj_A):
# ui.down_life()
obj_A.dead = True
elif isinstance(obj_A, Nave):
if self.speed:
obj_A.speed = 3
else:
obj_A.speed = 0
for obj_B in self.in_scene:
if not (obj_A == obj_B):
if isinstance(obj_B, Power_up) and self.collide(
obj_B, obj_A):
obj_B.dead = True
self.sound_power.play()
if obj_B.skin == 0:
ui.up_life()
elif obj_B.skin == 1:
self.hack = True
self.elapsed_time_power_shoot = 0
elif obj_B.skin == 2:
self.speed = True
self.elapsed_time_power_speed = 0
self.spawn_asteroide()
self.spawn_inimigos()
self.spawn_powers()
self.update()
# Checa se a musica de fundo acabou e reinicia caso positivo
def check_end_backm(self):
if self.sound_inGame.isFinished():
self.sound_inGame.play()
# Atualiza o tempo dos temporizadores
def update_time(self):
self.elapsed_time_shoot += time()
self.elapsed_time_asteroide += time()
self.elapsed_time_inimigo += time()
self.elapsed_time_planet += time()
self.elapsed_time_stars += time()
self.elapsed_time_powers += time()
if self.hack:
self.elapsed_time_power_shoot += time()
if self.elapsed_time_power_shoot >= POWER_UP_SHOOT:
self.hack = False
if self.speed:
self.elapsed_time_power_speed += time()
if self.elapsed_time_power_speed >= POWER_UP_SPEED:
self.speed = False
# Faz a criacao das estrelas, com uma posicao e escala aleatoria
def spawn_stars(self):
if self.elapsed_time_stars >= SPAWN_TIME_STARS:
position = randint(-70, 70)
scale = self.rand_tam_star()
new_star = Star(position, scale)
self.ornaments.append(new_star)
self.elapsed_time_stars = 0
# Faz a criacao dos planetas, com uma posicao e escala aleatoria
def spawn_planets(self):
if self.elapsed_time_planet >= SPAWN_TIME_PLANET:
position = randint(-50, 50)
scale = self.rand_tam()
new_planet = self.planets_queue.pop()
new_planet.load(position, scale, self.img_planets)
self.ornaments.append(new_planet)
self.elapsed_time_planet = 0
# Retorna um tamanho aleatorio para os planetas
def rand_tam(self):
return float(str(randint(0, 2)) + "." + str(randint(1, 5)))
# Retorna um tamanho aleatorio para as estrelas
def rand_tam_star(self):
return float("0." + str(randint(1, 3)))
# Faz a criacao dos asteroides, com uma posicao aleatioria
def spawn_asteroide(self):
if self.elapsed_time_asteroide >= SPAWN_TIME:
new_aste = self.asteroid_queue.pop()
new_aste.load(randint(-49, 43))
self.in_scene.append(new_aste)
self.elapsed_time_asteroide = 0
# Faz a criacao dos power ups, com uma posicao aleatioria
def spawn_powers(self):
if self.elapsed_time_powers >= POWER_UP_TIME:
new_power = self.power_queue.pop()
new_power.load(randint(-49, 43), 60, self.power_up_vida,
self.power_up_shoot, self.power_up_speed)
self.in_scene.append(new_power)
self.elapsed_time_powers = 0
# Faz a criacao dos inimigos, com uma posicao aleatoria
def spawn_inimigos(self):
if self.elapsed_time_inimigo >= SPAWN_TIME_ENEMY:
new_inimigo = self.enemy_queue.pop()
new_inimigo.load(randint(-49, 43), self.animation_propellant_enemy,
self.img_nave_azul, self.img_nave_amarela,
self.img_nave_preta)
self.in_scene.append(new_inimigo)
self.elapsed_time_inimigo = 0
# Funcao para criacao dos tiros, tanto dos inimigos quanto do player
def create_shoot(self,
position,
position_y=None,
position_y_2=None,
is_enemy=False,
type="player",
qtd=None,
tiro_respectivo=None,
my_angle=None):
if is_enemy:
if qtd == 1:
new_shoot = self.bullets_queue.pop()
new_shoot.load(tiro_respectivo, position, position_y,
position_y_2, True, type, 0, my_angle)
self.in_scene.append(new_shoot)
elif qtd == 2:
new_shoot = self.bullets_queue.pop()
new_shoot.load(tiro_respectivo, position - 2.5, position_y,
position_y_2, True, type, 0, my_angle)
new_shoot2 = self.bullets_queue.pop()
new_shoot2.load(tiro_respectivo, position + 2.5, position_y,
position_y_2, True, type, 0, my_angle)
self.in_scene.append(new_shoot)
self.in_scene.append(new_shoot2)
elif qtd == 3:
new_shoot = self.bullets_queue.pop()
new_shoot.load(tiro_respectivo, position - 5, position_y,
position_y_2, True, type, 0, my_angle)
new_shoot2 = self.bullets_queue.pop()
new_shoot2.load(tiro_respectivo, position, position_y,
position_y_2, True, type, 0, my_angle)
new_shoot3 = self.bullets_queue.pop()
new_shoot3.load(tiro_respectivo, position + 5, position_y,
position_y_2, True, type, 0, my_angle)
self.in_scene.append(new_shoot)
self.in_scene.append(new_shoot2)
self.in_scene.append(new_shoot3)
self.sound_laser_enemy.play()
return
if self.elapsed_time_shoot >= SHOOT_TIME:
if self.myNave.moving_right:
adjust = 3
elif self.myNave.moving_left:
adjust = -3
else:
adjust = 0
if self.hack:
new_shoot = self.bullets_queue.pop()
new_shoot.load(self.img_tiro, position + adjust + 5,
self.myNave.get_y()[1],
self.myNave.get_y()[1] + 8, False, 1,
self.myNave.get_z()[0] + 10, 0)
new_shoot2 = self.bullets_queue.pop()
new_shoot2.load(self.img_tiro, position + adjust - 5,
self.myNave.get_y()[1],
self.myNave.get_y()[1] + 8, False, 1,
self.myNave.get_z()[0] + 10, 0)
new_shoot3 = self.bullets_queue.pop()
new_shoot3.load(self.img_tiro, position + adjust,
self.myNave.get_y()[1],
self.myNave.get_y()[1] + 8, False, 1,
self.myNave.get_z()[0] + 10, 0)
self.in_scene.append(new_shoot)
self.in_scene.append(new_shoot2)
self.in_scene.append(new_shoot3)
self.sound_laser.play()
else:
new_shoot = self.bullets_queue.pop()
new_shoot.load(self.img_tiro, position + adjust,
self.myNave.get_y()[1],
self.myNave.get_y()[1] + 8, False, 1,
self.myNave.get_z()[0] + 10, 0)
self.in_scene.append(new_shoot)
self.sound_laser.play()
self.elapsed_time_shoot = 0
# Checagem de colisao
# adaptado com o eixo z
def collide(self, A, B):
A_colliding_B_in_x = (A.get_x()[1] >= B.get_x()[0]
and A.get_x()[1] <= B.get_x()[1])
# or
B_colliding_A_in_x = (B.get_x()[1] >= A.get_x()[0]
and B.get_x()[1] <= A.get_x()[1])
A_colliding_B_in_y = (A.get_y()[1] >= B.get_y()[0]
and A.get_y()[1] <= B.get_y()[1])
# or
B_colliding_A_in_y = (B.get_y()[1] >= A.get_y()[0]
and B.get_y()[1] <= A.get_y()[1])
A_colliding_B_in_z = (A.get_z()[1] >= B.get_z()[0]
and A.get_z()[1] <= B.get_z()[1])
# or
B_colliding_A_in_z = (B.get_z()[1] >= A.get_z()[0]
and B.get_z()[1] <= A.get_z()[1])
return (A_colliding_B_in_x or B_colliding_A_in_x) and \
(A_colliding_B_in_y or B_colliding_A_in_y) and \
(A_colliding_B_in_z or B_colliding_A_in_z)
def active_hack(self):
self.hack = not self.hack
# Reinicia o jogo, seta todas as variaveis para o inicio
def reestart(self):
self.reloc()
self.started = False
self.player_move_left = False
self.player_move_right = False
self.myNave = Nave(self.animation_propellant_enemy, 0)
self.elapsed_time_shoot = 0
self.elapsed_time_asteroide = 0
self.elapsed_time_inimigo = 0
self.hack = False
self.in_scene = []
self.in_scene.append(self.myNave)
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/inGame.wav", self)
self.sound_inGame.play()
if self.myLogo_i.inited:
self.ornaments.remove(self.myLogo_i)
self.myLogo_i.inited = False
if self.myLogo_e.inited:
self.ornaments.remove(self.myLogo_e)
self.myLogo_e.inited = False
# Realoca os objetos atualmente na cena para suas respectivas filas
def reloc(self):
for obj in self.in_scene:
if isinstance(obj, Enemy):
self.enemy_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Asteroide):
self.asteroid_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Shoot):
self.bullets_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Explode):
self.explosion_queue.push(obj)
self.in_scene.remove(obj)
elif isinstance(obj, Power_up):
self.power_queue.push(obj)
self.in_scene.remove(obj)
for obj in self.ornaments:
if isinstance(obj, Flor):
self.flowers_queue.push(obj)
self.ornaments.remove(obj)
elif isinstance(obj, Planeta):
self.planets_queue.push(obj)
self.ornaments.remove(obj)
# Para o jogo
def stop(self):
self.reloc()
self.started = False
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/startScene.wav", self)
self.sound_inGame.play()
self.in_scene = []
self.ornaments.append(self.myLogo_i)
if self.myLogo_e.inited:
self.ornaments.remove(self.myLogo_e)
self.myLogo_e.inited = False
self.myLogo_i.inited = True
# Quando o jogador morre
def dead(self):
self.reloc()
self.myNave.dead = True
self.sound_inGame.stop()
self.sound_inGame = QSound("sound/gameOver.wav", self)
self.sound_death.play()
if self.sound_death.isFinished():
self.sound_inGame.play()
self.ornaments.append(self.myLogo_e)
self.myLogo_e.inited = True
def initializeGL(self):
glClearColor(0.0, 0.0, 0.0, 0.0)
glShadeModel(GL_SMOOTH)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_ALPHA_TEST)
glAlphaFunc(GL_NOTEQUAL, 0.0)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(45, 1.65, 0.1, 500)
gluLookAt(0, -100, 50, 0, 0, 0, 0, 1, 0)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
self.myNave = Nave(self.animation_propellant_enemy, 0)
self.in_scene.append(self.myNave)
for i in range(EXPLOSION_FRAMES):
self.animation_explosion[i] = self.loadImage("img/explosion/Comp" +
str(i) + ".png")
for i in range(PROPELLANT_FRAMES):
self.animation_propellant_enemy[i] = self.loadImage(
"img/fire/Comp" + str(i) + ".png")
for i in range(10):
self.img_planets[i] = self.loadImage("img/planets/planeta" +
str(i) + ".png")
self.img_nave_amarela = self.loadImage("img/nave4.png")
self.img_nave_azul = self.loadImage("img/nave1.png")
self.img_nave_preta = self.loadImage("img/nave3.png")
self.img_tiro_amarelo = self.loadImage("img/nave4_pow.png")
self.img_tiro_preto = self.loadImage("img/nave3_pow.png")
self.img_tiro_azul = self.loadImage("img/nave1_pow.png")
self.img_tiro = self.loadImage("img/nave2_pow.png")
self.logo_init = self.loadImage("img/SpaceCute.png")
self.logo_end = self.loadImage("img/YouDied.png")
self.power_up_vida = self.loadImage("img/power_up_life.png")
self.power_up_shoot = self.loadImage("img/power_up_shot.png")
self.power_up_speed = self.loadImage("img/power_up_speed.png")
self.myLogo_i.load("inicio", self.logo_init, self.logo_end)
self.ornaments.append(self.myLogo_i)
self.myLogo_i.inited = True
self.myLogo_e.load("fim", self.logo_init, self.logo_end)
self.init_queue()
# Arrumando erros de frict
fix_p = self.propellant_queue.pop()
fix_p.load(self.animation_propellant_enemy, 1000, 1000, "fix")
self.ornaments.append(fix_p)
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion, 1000, 1000, "fix")
self.ornaments.append(new_explosion)
tx = 0
ambiente = [0.2, 0.2, 0.2, 1.0]
difusa = [0.7, 0.7, 0.7, 1.0]
especular = [1.0, 1.0, 1.0, 1.0]
posicao = [0.0, 3.0, 2.0, 0.0]
lmodelo_ambiente = [0.2, 0.2, 0.2, 1.0]
glLightfv(GL_LIGHT0, GL_AMBIENT, ambiente)
glLightfv(GL_LIGHT0, GL_DIFFUSE, difusa)
glLightfv(GL_LIGHT0, GL_POSITION, posicao)
glLightfv(GL_LIGHT0, GL_SPECULAR, especular)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodelo_ambiente)
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glEnable(GL_COLOR_MATERIAL)
def selecao(self):
"""
Este metodo controla a selecao de jogadores e naves
"""
for i in range(2):
system("clear")
print("SELEÇÃO")
print("1 - Criar")
print("2 - Já tenho")
opcao = input(": ")
if opcao == "1":
print("\nJOGADOR")
while True:
nome = input("Nome: ").upper()
if not self.buscar_nome(nome):
break
else:
print("Este jogador já existe.\n")
print("\nNAVE")
print(
"Você tem 10 pontos para distribuir (entre velocidade máxima, aceleração e escudo)."
)
while True:
try:
velocidade_maxima = int(
input("Velocidade máxima (1-5): "))
aceleracao = int(input("Aceleração (1-5): "))
escudo = int(input("Escudo (0-5): "))
except:
print("Valor inválido!\n")
continue
if velocidade_maxima + aceleracao + escudo <= 10:
break
else:
print("Você gastou mais de 10 pontos.\n")
while True:
print("Cor:")
print("1 - vermelho")
print("2 - amarelo")
print("3 - verde")
print("4 - azul turquesa")
print("5 - azul")
print("6 - roxo")
try:
cor = int(input(": "))
except:
print("Valor inválido!\n")
continue
if cor > 0 and cor < 7:
break
else:
print("Cor inexistente.")
if i == 0:
nave = Nave(jogo.ambiente, cor, Vetor(200, 300),
velocidade_maxima, aceleracao * 0.5, escudo, 0)
else:
nave = Nave(jogo.ambiente, cor, Vetor(1000, 300),
velocidade_maxima, aceleracao * 0.5, escudo, 1)
self.lista_naves.append(nave)
self.salvar_configuracao(nome, cor, velocidade_maxima,
aceleracao * 0.5, escudo)
elif opcao == "2":
nome = input("Nome: ").upper()
configuracao = self.ler_configuracao(nome)
if i == 0:
nave = Nave(jogo.ambiente, configuracao[0],
Vetor(200, 300), configuracao[1],
configuracao[2], configuracao[3], 0)
else:
nave = Nave(jogo.ambiente, configuracao[0],
Vetor(1000, 300), configuracao[1],
configuracao[2], configuracao[3], 1)
self.lista_naves.append(nave)
else:
print("Opção inválida")
sys.exit()
