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__(self, menu, currentPlayer):
""" """
PygameScreen.__init__(self)
self.currentPlayer = currentPlayer
self.menu = menu
self.logo = Logo()
name = "None"
if currentPlayer is not None:
name = currentPlayer.fullname
self.playerLabel = Label("{0}: {1}".format("Player", name),
size=24,
color=(0, 0, 0))
self.menuView = MainMenuWidget(menu)
def __init__(self, win, seeds):
self.paused = False
self.multi_logoview = True
self.win = win
self.single_logoview = None
width = win.width / 3
height = win.height / 3
self.logoviews = [LogoView((0, int(win.height/1.5)), (width, height),
Logo([textgen.TextGen()])),
LogoView((width, int(win.height/1.5)), (width, height),
Logo([lsysgen.LSysGen(), polygen.PolyGen(),
polygen.PolyGen(), polygen.PolyGen()])),
LogoView((int(win.width/1.5), int(win.height/1.5)), (width, height),
Logo([polygen.PolyGen(), polygen.PolyGen(),
lsysgen.LSysGen()])),
LogoView((0, height), (width, height),
Logo([polygen.PolyGen()])),
LogoView((width, height), (width, height),
Logo([lsysgen.LSysGen(), lsysgen.LSysGen()])),
LogoView((int(win.width/1.5), height), (width, height),
Logo([polygen.PolyGen()])),
LogoView((0, 0), (width, height),
Logo([lsysgen.LSysGen()])),
LogoView((width, 0), (width, height),
Logo([polygen.PolyGen()])),
LogoView((int(win.width/1.5), 0), (width, height),
Logo())
]
if seeds == None:
self.create_seeds_for_all_generators(0)
# Mix the second and third logo to form a new one, and place it
# in the lower right position.
logo = Logo.mix_of(self.logoviews[1].logo, self.logoviews[2].logo)
mixed_view = LogoView((int(win.width/1.5), 0),
(width, height), logo)
self.logoviews[8] = mixed_view
else:
newgens = []
for seed in seeds:
(module, generator) = seed.get('__generator__',
('polygen', 'PolyGen'))
genclass = reduce(getattr, [generator], sys.modules[module])
gen = genclass()
gen.seed = seed
newgens.append(gen)
for view in self.logoviews:
view.logo = Logo(newgens)
print(self.logoviews)
pyglet.clock.schedule_interval(self.create_seeds_for_all_generators, 10)
def run_game():
# initialize game
pygame.mixer.pre_init(22050, -16, 2, 512)
pygame.mixer.init()
pygame.init()
screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
screen_rect = screen.get_rect()
# images import
icon = pygame.image.load("resources/icon.jpeg")
ship_img = pygame.image.load("resources/ship.bmp")
logo_img = pygame.image.load("resources/logo.png")
alien_img = pygame.image.load("resources/alien.bmp")
back_img = pygame.image.load("resources/background.png")
backg = pygame.transform.scale(back_img,
(screen_rect.width, screen_rect.height))
# soundtrack
pygame.mixer.music.load("resources/Starlight.ogg")
pygame.mixer.music.play(loops=-1) # -1 = loop
# sound effects
laser_shot = pygame.mixer.Sound("resources/laser-shoot.ogg")
alien_exp = pygame.mixer.Sound("resources/alien-explosion-1.ogg")
pygame.display.set_icon(icon)
# class istances
aliens = Group()
bullets = Group()
ai_set = Settings(screen)
stats = GameStats(ai_set)
logo = Logo(screen, logo_img)
sb = Scoreboard(screen, stats, ship_img, ai_set)
ship = Ship(screen, ai_set, ship_img)
play_b = Button(ai_set, screen, "Play")
# functions
pygame.display.set_caption("Alien Invasion")
gf.create_fleet(ai_set, screen, aliens, ship, alien_img)
# main loop
while True:
screen.blit(backg, (0, 0))
gf.check_events(ai_set, screen, aliens, ship, stats, bullets, play_b,
alien_img, laser_shot, sb)
if stats.game_active:
ship.update()
gf.update_bullets(bullets, aliens, ai_set, screen, ship, alien_exp,
alien_img, stats, sb)
gf.update_aliens(ai_set, stats, screen, aliens, ship, bullets,
alien_img, sb)
gf.update_screen(ai_set, screen, ship, aliens, bullets, play_b, stats,
logo, sb)
pygame.quit()
def test_multiple_generator_logos_mixed_should_adhere_to_rules(self):
l1 = Logo([lsysgen.LSysGen(), polygen.PolyGen(),
polygen.PolyGen(), polygen.PolyGen()])
l2 = Logo([polygen.PolyGen(), polygen.PolyGen(),
lsysgen.LSysGen()])
l3 = Logo.mix_of(l1, l2)
assert_that(len(l3), is_(4))
def test_mix_of_two_logos_with_one_different_gen_each_should_contain_two_unchanged_gens(self):
poly_gen = polygen.PolyGen()
text_gen = textgen.TextGen()
l1 = self.create_logo([ poly_gen ])
l2 = self.create_logo([ text_gen ])
l3 = Logo.mix_of(l1, l2)
assert_that(len(l3), is_(2))
assert_that(l3, contains_inanyorder(poly_gen, text_gen))
def test_mix_of_two_logos_with_one_polygen_each_should_contain_one_new_polygen(self):
l1 = self.create_logo([ polygen.PolyGen() ])
l2 = self.create_logo([ polygen.PolyGen() ])
mixed = Logo.mix_of(l1, l2)
assert_that("Mixed logo does not have one generator",
len(mixed), is_(1))
assert_that("Mixed logo's first generator is not a PolyGen",
mixed[0], is_(instance_of(polygen.PolyGen)))
assert_that("Mixed logo's first generator is one of the original PolyGens",
mixed[0], is_not(is_in([l1, l2])))
def __init__(self):
QWidget.__init__(self)
self._ui_model = None
self._logo = Logo()
self._render_stats = RenderStats()
v = QVBoxLayout()
v.addWidget(self._logo)
v.addWidget(AboutMessage())
v.addWidget(self._render_stats)
self.setLayout(v)
def runLoadingScreen():
# Initialize the window to display the screen on
pygame.init()
dvdSettings = Settings()
screen = pygame.display.set_mode(
(dvdSettings.screenWidth, dvdSettings.screenHeight))
pygame.display.set_caption("DVD Loading Screen")
# Set a background color
bgColor = dvdSettings.bgColor
# Create an instance of the image
logo = Logo(dvdSettings, screen)
# Set the mouse to be invisible
pygame.mouse.set_visible(False)
running = True
while running:
af.checkEvents()
logo.update(dvdSettings)
af.updateScreen(screen, dvdSettings, logo)
def __init__(self, menu, currentPlayer):
""" """
PygameScreen.__init__(self)
self.currentPlayer = currentPlayer
self.menu = menu
self.logo = Logo()
name = "None"
if currentPlayer is not None:
name = currentPlayer.fullname
self.playerLabel = Label("{0}: {1}".format("Player", name), size=24, color=(0, 0, 0))
self.menuView = MainMenuWidget(menu)
class About(QWidget):
def __init__(self):
QWidget.__init__(self)
self._ui_model = None
self._logo = Logo()
self._render_stats = RenderStats()
v = QVBoxLayout()
v.addWidget(self._logo)
v.addWidget(AboutMessage())
v.addWidget(self._render_stats)
self.setLayout(v)
def set_ui_model(self, ui_model):
self._ui_model = ui_model
self._logo.set_ui_model(ui_model)
self._render_stats.set_ui_model(ui_model)
def unregister_updaters(self):
self._logo.unregister_updaters()
self._render_stats.unregister_updaters()
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.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.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.animation_explosion = [None for i in range(EXPLOSION_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.myLogo_i = Logo()
self.myLogo_e = Logo()
self.myNave = None
self.skybox = None
def run_game():
# 初始化背景设置
image_list = gf.init_images()
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
background = Background(ai_settings, screen)
stats = GameStats(ai_settings)
sb = Stepboard(ai_settings, screen, stats)
pygame.display.set_caption("图片华容道")
logo = Logo(ai_settings, screen)
# 创建开始游戏按钮
play_button = Button(ai_settings, screen, stats, "",
"images_material/play_button.png")
replay_button = Button(ai_settings, screen, stats, "",
"images_material/again.png")
exit_button = Button(ai_settings, screen, stats, "",
"images_material/exit_button.png")
back_button = Button(ai_settings, screen, stats, "",
"images_material/back.png")
reset_button = Button(ai_settings, screen, stats, "",
"images_material/reset.png")
# 创建滑块列表
blocks = list()
# 填充滑块列表
gf.create_all_blocks(ai_settings, screen, blocks,
image_list) # 把切割好的图像列表传进来
BLOCKS_ORI = list(blocks)
reset_blocks = list()
# 开始游戏主循环
while True:
# 监视键盘和鼠标事件
gf.check_events(ai_settings, screen, blocks, BLOCKS_ORI, reset_blocks,
stats, sb, play_button, replay_button, reset_button,
exit_button, back_button, image_list)
if stats.game_menu:
gf.update_screen_menu(ai_settings, screen, blocks, stats, sb,
play_button, exit_button, logo, background)
else:
gf.update_screen_playing(ai_settings, screen, blocks, stats, sb,
replay_button, back_button, reset_button,
background)
def initUI(self):
"""Initialize GUI elements"""
self.main_layout = QVBoxLayout()
self.create_stats_gb()
self.main_layout.addWidget(HLine())
self.create_dataset_gb()
self.main_layout.addWidget(HLine())
self.create_brain_gb()
self.main_layout.addWidget(HLine())
self.create_simulation_gb()
self.main_layout.addWidget(HLine())
self.topics_popup = TopicsPopup()
logo = Logo()
social = SocialMedia()
self.main_layout.addWidget(social)
self.main_layout.addWidget(logo)
self.setLayout(self.main_layout)
class MainMenuScreen(PygameScreen):
""" Represents the Main Menu screen """
def __init__(self, menu, currentPlayer):
""" """
PygameScreen.__init__(self)
self.currentPlayer = currentPlayer
self.menu = menu
self.logo = Logo()
name = "None"
if currentPlayer is not None:
name = currentPlayer.fullname
self.playerLabel = Label("{0}: {1}".format("Player", name),
size=24,
color=(0, 0, 0))
self.menuView = MainMenuWidget(menu)
def drawSurface(self):
""" Draws the screen to the provided window """
self.drawMap()
self.drawOnSurface(self.playerLabel.draw(), right=1, top=0)
self.drawLogo()
self.drawMenu()
def drawMap(self):
""" Draws the map to the window """
mapSurface = map.draw()
self.drawOnSurface(mapSurface, left=0, top=0)
def drawLogo(self):
""" Draws the Logo to the window """
logoSurface = self.logo.draw()
self.drawOnSurface(logoSurface, centerx=.5, centery=.25)
def drawMenu(self):
""" Draws the Menu to the window """
menuSurface = self.menuView.draw()
self.drawOnSurface(menuSurface, centerx=.5, centery=11.0 / 16)
class MainMenuScreen(PygameScreen):
""" Represents the Main Menu screen """
def __init__(self, menu, currentPlayer):
""" """
PygameScreen.__init__(self)
self.currentPlayer = currentPlayer
self.menu = menu
self.logo = Logo()
name = "None"
if currentPlayer is not None:
name = currentPlayer.fullname
self.playerLabel = Label("{0}: {1}".format("Player", name), size=24, color=(0, 0, 0))
self.menuView = MainMenuWidget(menu)
def drawSurface(self):
""" Draws the screen to the provided window """
self.drawMap()
self.drawOnSurface(self.playerLabel.draw(), right=1, top=0)
self.drawLogo()
self.drawMenu()
def drawMap(self):
""" Draws the map to the window """
mapSurface = map.draw()
self.drawOnSurface(mapSurface, left=0, top=0)
def drawLogo(self):
""" Draws the Logo to the window """
logoSurface = self.logo.draw()
self.drawOnSurface(logoSurface, centerx=.5, centery=.25)
def drawMenu(self):
""" Draws the Menu to the window """
menuSurface = self.menuView.draw()
self.drawOnSurface(menuSurface, centerx=.5, centery=11.0/16)
def initUI(self):
"""Initialize the GUI elements"""
main_layout = QVBoxLayout()
self.setStyleSheet('background-color: rgb(51,51,51); color: white')
self.setLayout(main_layout)
# define view's widgets
logo = Logo()
self.base = LayoutMatrix()
confirm_button = QPushButton("Confirm", self)
confirm_button.setFixedSize(100, 50)
confirm_button.clicked.connect(self.confirm)
preview_button = QPushButton("Preview", self)
preview_button.setFixedSize(100, 50)
preview_button.clicked.connect(self.preview_win)
clear_button = QPushButton("Clear", self)
clear_button.setFixedSize(100, 50)
clear_button.clicked.connect(self.clear)
lbl = AnimatedLabel(self)
# insert widgets in layouts
butons_layout = QHBoxLayout()
butons_layout.addWidget(clear_button)
butons_layout.addWidget(preview_button)
butons_layout.addWidget(confirm_button)
butons_layout.addWidget(InfoLabel(parent=self))
main_layout.addWidget(logo)
main_layout.addWidget(self.base)
main_layout.addLayout(butons_layout)
main_layout.addWidget(lbl)
self.show_information_popup()
def run_game():
"""Run the game
...
This function starts the game. It initializes pygame, instantiates the
screen, play button, stats, scoreboard, corgi, borks, kitties and an army
thereof. It then starts the main loop which updates the screen and checks
for events. When the game is active, it also updates the corgi, the borks
and the kitties."""
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption(settings.caption)
logo = Logo(settings, screen)
play_button = Button(screen, settings, settings.play_button_text)
stats = GameStats(settings)
scoreboard = Scoreboard(settings, screen, stats)
corgi = Corgi(settings, screen)
borks = Group()
kitties = Group()
gf.create_army(settings, screen, corgi, kitties)
# game loop
while True:
gf.update_screen(settings, screen, stats,
scoreboard, corgi, kitties, borks, play_button, logo)
gf.check_events(settings, screen, stats,
scoreboard, play_button, kitties, corgi, borks)
if stats.game_active:
corgi.update()
gf.update_borks(settings, screen, stats,
scoreboard, corgi, kitties, borks)
gf.update_kitties(settings, stats, screen,
scoreboard, corgi, kitties, borks)
class MainMenuScreen(ConsoleScreen):
""" Represents the Main Menu screen """
def __init__(self, menu):
""" """
self.menu = menu
self.logo = Logo()
self.menuView = MenuView(menu)
def draw(self):
""" Draws the screen """
self.drawLogo()
self.drawMenu()
def drawLogo(self):
""" Draws the Logo to the window """
logoText, logoSize = self.logo.draw()
self.drawCenteredText(logoText, logoSize, .5, .25)
def drawMenu(self):
""" Draws the Menu to the window """
menuText, menuSize = self.menuView.draw()
self.drawCenteredText(menuText, menuSize, .5, 11.0/16)
def test_mix_two_textgens_and_one_polygen_should_get_one_mixed_textgen_and_one_unchanged_polygen(self):
poly_gen = polygen.PolyGen()
text_gen1 = textgen.TextGen()
text_gen2 = textgen.TextGen()
l1 = self.create_logo([ poly_gen, text_gen1 ])
l2 = self.create_logo([ text_gen2 ])
mixed = Logo.mix_of(l1, l2)
# Many asserts, but we want to be strict here
# The mixed Logo shall:
# * Only have two elements.
# * Contain the original poly_gen.
# * Not contain any of the original text_gens
# * Contain one TextGen
assert_that("Mixed Logo does not have two generators",
len(mixed), is_(2))
assert_that("Mixed Logo does not contain the original PolyGen",
mixed, has_item(poly_gen))
assert_that("Mixed Logo contains the original TextGens",
mixed, is_not(has_items([text_gen1, text_gen2])))
assert_that("Mixed Logo does not contain a TextGen",
mixed, has_item(instance_of(textgen.TextGen)))
from logo import Logo
def save_fix_height(img, name, root='./Logos/', fixed_height=120):
width, height = img.size
width = int(width * fixed_height / height)
size = (width, fixed_height)
img = img.resize(size, Image.ANTIALIAS)
if not os.path.exists(root): os.makedirs(root)
img.save(root + name + '.bmp', quality=100)
if __name__ == '__main__':
logo = Logo()
# example 1
logo.set_font('typography')
logo.set_colors('Noon to Dusk')
logo.set_content('curme')
logo_img = logo.draw()
save_fix_height(logo_img, 'example1')
# example 2
with open('./Workers/gea6.logo', 'r+') as f:
layout = f.read().split('\n')
logo.set_layout(layout)
logo.set_colors('Sea Blue')
logo_img = logo.draw()
save_fix_height(logo_img, 'example2')
arduino_port.open()
#initialize simulation
pygame.init()
pygame.mixer.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Mathstronauts Autonomous Vehicle Simulator")
clock = pygame.time.Clock()
#create sprites
road_1 = Road()
road_2 = Road()
road_2.rect.center = (WIDTH / 2, -1 * (HEIGHT / 2))
host = Host_Vehicle()
laterals_randomLane_slower = Laterals_RandomLane_Slower_TV()
logo = Logo()
logo2 = Logo()
logo2.rect.centerx = 1200 - (600 - 270) / 2
#create sprite groups
all_sprites = pygame.sprite.Group()
road_background = pygame.sprite.Group()
cars = pygame.sprite.Group()
targets = pygame.sprite.Group()
#add sprites to the appropriate sprite groups
all_sprites.add(host)
all_sprites.add(road_1)
all_sprites.add(road_2)
road_background.add(road_1)
def create_world():
global logo
logo = Logo()
def main():
"""
on cree un dessin a l’aide de l’objet logo.
"""
tortue = Logo()
tortue.leve_crayon()
tortue.tourne_droite(180.0)
tortue.avance(50.0)
tortue.tourne_gauche(90.0)
tortue.avance(50.0)
tortue.tourne_gauche(90.0)
tortue.baisse_crayon()
tortue.avance(20.0)
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.leve_crayon()
tortue.avance(20.0)
tortue.baisse_crayon()
tortue.avance(20.0)
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.leve_crayon()
tortue.tourne_droite(90.0)
tortue.avance(20.0)
tortue.tourne_gauche(90.0)
tortue.avance(10.0)
tortue.baisse_crayon()
tortue.tourne_gauche(45.0)
tortue.avance(30.0)
tortue.tourne_gauche(45.0)
tortue.avance(30.0)
tortue.tourne_gauche(45.0)
tortue.avance(30.0)
# @author huizhan
import os
from logo import Logo
if __name__ == '__main__':
store_root = './Logos/'
logo = Logo()
content = 'gea6'
with open('./Workers/gea6.logo', 'r+') as f:
layout = f.read().split('\n')
logo.set_layout(layout)
# get colors
colors = os.listdir('./Colors/')
colors = [color.split('.')[0] for color in \
colors if color.split('.')[-1]=='jpg']
for color in colors:
logo.set_colors(color)
logo_img = logo.draw()
save_path = store_root + content + '/'
img_name = color + '.bmp'
if not os.path.exists(save_path): os.makedirs(save_path)
logo_img.save(save_path + img_name)
# @author huizhan
import os
from logo import Logo
if __name__ == '__main__':
store_root = './Logos/'
logo = Logo()
content = 'curme'
# get fonts
fonts = os.listdir('./Fonts/')
fonts = [font for font in fonts \
if len(font.split('.'))==1]
# get colors
colors = os.listdir('./Colors/')
colors = [color.split('.')[0] for color in \
colors if color.split('.')[-1]=='jpg']
for font in fonts:
logo.set_font(font)
logo.set_content(content)
for color in colors:
logo.set_colors(color)
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 enter():
global logo
open_canvas(1024, 768)
hide_lattice()
logo = Logo()
class main(QtWidgets.QOpenGLWidget):
# Cria as variaveis necessarias
# self.started = Indica se o jogo foi iniciado ou nao
# self.in_scene = Vetor para a cena (tudo que faz parte do jogo e sera desenhado)
# self.ornaments = Vetor para a beleza da cena (tudo que sao apenas "flores")
#
# Temporizadores
# self.elapsed_time_shoot = Tempo desde o ultimo tiro do player
# self.elapsed_time_asteroide = Tempo desde o ultimo asteroide criado
# self.elapsed_time_inimigo = Tempo desde o ultimo inimigo criado
# self.elapsed_time_flower = Tempo desde a ultima flor criada
# self.elapsed_time_planet = Tempo desde o ultimo planeta criado
# self.elapsed_time_stars = = Tempo desde a ultima estrela criada
#
# Sons
# self.sound_laser = Tiro do player
# self.sound_laser_enemy = Tiro do inimigo
# self.sound_explosion = Explosao
# self.sound_1000pts = 1000 pontos alcancados
# self.sound_inGame = Fundo do jogo
# self.sound_death = Morte
#
# Filas para pre carregamento dos objetos
# self.enemy_queue = Fila dos inimigos
# self.asteroid_queue = Fila dos Asteroides
# self.bullets_queue = Fila das balas
# self.flowers_queue = Fila das flores
# self.planets_queue = Fila dos planetas
# self.explosion_queue = Fila das explosoes
# self.propellant_queue = Fila dos propulsores
#
# Variaveis para pre carregamento das texturas
# self.animation_explosion
# self.animation_propellant_enemy
# self.img_nave_azul
# self.img_nave_amarela
# self.img_nave_preta
# self.img_tiro_azul
# self.img_tiro_preto
# self.img_tiro_amarelo
# self.img_tiro
# self.logo_init
# self.logo_end
# self.imageID_back
# self.myLogo_i = Logo()
# self.myLogo_e = Logo()
#
# self.myNave = Nave do jogador
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_flower = 500000000000 / 2
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.flowers_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 = Flor()
self.flowers_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_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, 0)
self.in_scene.append(self.myNave)
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")
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, 70, 70, "fix")
self.ornaments.append(fix_p)
new_explosion = self.explosion_queue.pop()
new_explosion.load(self.animation_explosion, 70, 70, "fix")
self.ornaments.append(new_explosion)
# 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_Up:
self.myNave.shooting = True
if event.key() == QtCore.Qt.Key_W:
self.myNave.shooting = True
# if event.key() == QtCore.Qt.Key_T:
# self.hack = 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_Up:
self.myNave.shooting = False
if event.key() == QtCore.Qt.Key_W:
self.myNave.shooting = False
if event.key() == QtCore.Qt.Key_T:
self.hack = 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()
# Desenha o background
''''' Inicio do 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)
''''' Fim do background ''' ''
self.update_time()
self.spawn_flowers()
self.spawn_planets()
self.spawn_stars()
# 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, 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)
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()
# print (self.enemy_queue.tam())
# Verifica se o jogo foi iniciado
if (not self.started):
return
# 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:
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):
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_flower += 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(-49, 49)
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 das flores, com uma posicao aleatoria
def spawn_flowers(self):
if self.elapsed_time_flower >= SPAWN_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
# 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):
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)
self.sound_laser.play()
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.sound_laser.play()
self.elapsed_time_shoot = 0
# Checagem de colisao
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
# 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
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
from tkinter import *
from logo import Logo
window_size = (960, 640)
root = Tk()
root.title('DVD Screensaver')
root.geometry('{}x{}'.format(window_size[0], window_size[1]))
root.minsize(width=256, height=256)
Logo(root, window_size)
root.mainloop()
def initUi(self):
self.logo = Logo()
self.mayaWiget = pm.text()
self.mayaText = mayaToQtObject(self.mayaWiget)
self.setWindowTitle('Alfred Camera Tool')
self.centralWidget = QtGui.QWidget()
self.setCentralWidget(self.centralWidget)
self.mainLayoyt = QtGui.QVBoxLayout()
self.centralWidget.setLayout(self.mainLayoyt)
# Create Camera UI
self.creationGroup = QtGui.QGroupBox('Create')
self.creationLayout = QtGui.QGridLayout()
self.creationGroup.setLayout(self.creationLayout)
cameraNameLabel = QtGui.QLabel('Camera Name:')
cameraNameLabel.setAlignment(QtCore.Qt.AlignRight)
self.cameraLineEdit = QtGui.QLineEdit()
self.createCameraPushBtn = QtGui.QPushButton('Create Camera')
self.creationLayout.addWidget(cameraNameLabel, 0, 0)
self.creationLayout.addWidget(self.cameraLineEdit, 0, 1)
self.creationLayout.addWidget(self.createCameraPushBtn, 1, 1)
# Edit Camera UI
self.editGroup = QtGui.QGroupBox('Edit')
self.editLayout = QtGui.QGridLayout()
self.editGroup.setLayout(self.editLayout)
renameLabel = QtGui.QLabel('Camera Rename:')
self.renameLineEdit = QtGui.QLineEdit()
self.renameButton = QtGui.QPushButton('Rename')
matchFilmLabel = QtGui.QLabel('Match Filmback \nto Resolution:')
matchFilmLabel.setWordWrap(True)
self.matchButton = QtGui.QPushButton('Match')
setRangeLabel = QtGui.QLabel('Set Playback \nRange of Camera:')
setRangeLabel.setWordWrap(True)
self.setRangeButton = QtGui.QPushButton('Set Range')
self.editLayout.addWidget(renameLabel, 0, 0)
self.editLayout.addWidget(self.renameLineEdit, 0, 1)
self.editLayout.addWidget(self.renameButton, 1, 1)
self.editLayout.addWidget(matchFilmLabel, 2, 0)
self.editLayout.addWidget(self.matchButton, 2, 1)
self.editLayout.addWidget(setRangeLabel, 4, 0)
self.editLayout.addWidget(self.setRangeButton, 4, 1)
# Operation
self.operationGroup = QtGui.QGroupBox('Operation')
operationLayout = QtGui.QHBoxLayout()
self.renderableButton = QtGui.QPushButton('Renderable')
self.bakeButton = QtGui.QPushButton('Bake')
self.deleteButton = QtGui.QPushButton('Delete')
operationLayout.addWidget(self.renderableButton)
operationLayout.addWidget(self.bakeButton)
operationLayout.addWidget(self.deleteButton)
self.operationGroup.setLayout(operationLayout)
#self.mainLayoyt.addWidget(self.logo)
self.mainLayoyt.addWidget(self.creationGroup)
self.mainLayoyt.addWidget(self.editGroup)
self.mainLayoyt.addWidget(self.operationGroup)
self.mainLayoyt.addWidget(self.mayaText)
self.mayaText.setVisible(False)
self.mainLayoyt.addStretch()
self.status = self.statusBar()
self.setDefaultUI()
#Set Window
windowLogoImage = QtGui.QPixmap(
os.path.join(self.imagePath, 'camera.png'))
windowLogoIcon = QtGui.QIcon(windowLogoImage)
self.setWindowIcon(windowLogoIcon)
self.setFixedWidth(300)
self.setStyleSheet(self.stylData)
self.setObjectName('alfredCamUI')
def __init__(self, menu):
""" """
self.menu = menu
self.logo = Logo()
self.menuView = MenuView(menu)
def initUI(self):
"""Initialize the GUI elements"""
main_layout = QVBoxLayout()
self.setStyleSheet('background-color: rgb(51,51,51)')
self.setLayout(main_layout)
logo = Logo()
self.v3d = View3D(self.robot_type, self)
frame = QFrame(self)
self.r1_layout = QHBoxLayout()
with open(resources_path + 'worlds.json') as f:
data = f.read()
worlds = json.loads(data)[self.robot_type]
myQListWidget = QListWidget()
myQListWidget.setStyleSheet("border: 0px;")
myQListWidget.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
myQListWidget.verticalScrollBar().setSingleStep(10)
myQListWidget.setMaximumWidth(800)
for world in worlds:
myQCustomQWidget = QCustomQWidget(world, self)
myQCustomQWidget.setTextUp(world['name'])
myQListWidgetItem = QListWidgetItem(myQListWidget)
myQListWidgetItem.setSizeHint(QSize(100, 80))
myQListWidget.addItem(myQListWidgetItem)
myQListWidget.setItemWidget(myQListWidgetItem, myQCustomQWidget)
self.r1_layout.addWidget(self.v3d)
self.r1_layout.addWidget(myQListWidget)
frame.setLayout(self.r1_layout)
# enable_gui = QCheckBox(self)
# enable_gui.setText("Gazebo GUI")
# enable_gui.setStyleSheet("""QCheckBox { color: white; font-size: 20px;}
# QCheckBox::indicator {
# border: 1px solid white;
# background: white;
# height: 10px;
# width: 10px;
# border-radius: 2px
# }
# """)
# # enable_gui.setStyleSheet("""QCheckBox; QCheckBox::indicator { width: 400px; height: 400px;}""")
# enable_gui.stateChanged.connect(self.handle_gazebo_gui)
# enable_gui.setFixedHeight(50)
font = QFont('Arial', 30)
lbl = ClickableLabel(self)
lbl.setFont(font)
lbl.setText("Select your world")
lbl.setFixedHeight(100)
lbl.setAlignment(Qt.AlignCenter)
lbl.setStyleSheet('color: yellow')
main_layout.addWidget(logo)
main_layout.addWidget(frame)
# main_layout.addWidget(enable_gui, 2, Qt.AlignCenter)
main_layout.addWidget(lbl)
