class GameWindow(pyglet.window.Window):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.set_location(400, 100)
self.frame_rate = 1/60.0
self.player = GameObject( posx = 200, posy = 200 ,image = "Mario_Super.png")
self.enemie1 = Enemies(posx=500, posy=200, image="goomba_1.png")
self.enemie2 = Enemies(posx=300, posy=200, image="goomba_1.png")
self.background = BackgroundObject(posx = 0, posy = 0, image ='background_0.jpg')
self.brick = BackgroundObject(posx=0, posy=0, image='brick.png')
def on_key_press(self, symbol, modifiers):
if symbol == key.RIGHT:
self.player.velx = 150
self.background.velx = -150
if symbol == key.LEFT:
self.player.velx = -150
self.background.velx = 150
if symbol == key.UP:
self.player.vely = 150
if symbol == key.DOWN:
self.player.vely = -150
if symbol == key.A:
self.player.imageList = self.player.image_list_attack
if symbol == key.W:
self.player.imageList = self.player.image_list_walk
self.background.velx = -150
if symbol == key.S:
self.player.imageList = self.player.image_list_swim
if symbol == key.D:
self.player.imageList = self.player.image_list_dash
if symbol == key.J:
self.player.imageList = self.player.image_list_jump
if symbol == key.C:
self.player.imageList = self.player.image_list_climb
def on_key_release(self, symbol, modifiers):
if symbol in (key.RIGHT, key.LEFT):
self.player.velx = 0
self.background.velx = 0
if symbol in (key.UP, key.DOWN, key.C):
self.player.vely =0
if symbol in (key.A, key.W, key.S, key.D, key.J, key.C):
self.player.imageList = self.player.image_list_default
self.background.velx = 0
def on_draw(self):
self.clear()
self.background.draw()
self.brick.draw()
self.player.draw()
self.enemie1.draw()
self.enemie2.draw()
def update(self, dt):
self.player.update(dt)
self.background.update()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.set_location(400, 100)
self.frame_rate = 1/60.0
self.player = GameObject( posx = 200, posy = 200 ,image = "Mario_Super.png")
self.enemie1 = Enemies(posx=500, posy=200, image="goomba_1.png")
self.enemie2 = Enemies(posx=300, posy=200, image="goomba_1.png")
self.background = BackgroundObject(posx = 0, posy = 0, image ='background_0.jpg')
self.brick = BackgroundObject(posx=0, posy=0, image='brick.png')
def __init__(self):
self.map = Map()
self.towers = Towers(self.map)
self.enemies = Enemies(self.map, self.towers)
self.menu = Menu(self.map, self.towers, self.enemies, screen_width,
screen_height)
self.dragging_tower = False
self.round = 1
self.start_round()
class Environments:
def __init__(self, level):
self.enemies = Enemies(characterlevel=level)
def dungeon(self):
mobs = list()
boss = self.enemies.ogre()
for i in range(2, 8):
mobs.append(self.enemies.skeleton())
for i in range(5, 17):
mobs.append(self.enemies.bat())
objtoreturn = {'name': 'Dungeon', 'mobs': mobs, 'boss': boss}
return objtoreturn
def run_game():
#функция подключает pygame, настройки, создает экран, инициализирует все модули и запускает основной цикл игры
pygame.init()
#определяет настройки
nlo_settings = Settings()
#определяет экран
screen = pygame.display.set_mode(
(nlo_settings.screen_width, nlo_settings.screen_height))
#создает название
pygame.display.set_caption("N L O")
#создание корабля
korabl = Korabl(nlo_settings, screen)
#создание щита
sfera = Sfera(nlo_settings, screen, korabl)
#изображение
fon = pygame.image.load('images/fon.png')
#группа для хранения пуль
pyli = Group()
#группа для хранения врагов
enemies = Enemies(nlo_settings, screen)
#группа для хранения пуль врагов
bullets = Group()
#группа для хранения жизней корабля
all_lifes = Group()
#создание трех жизней
gf.all_lifes(screen, all_lifes, nlo_settings)
#создание надписи приветствия
welcome = Game_over(screen, 'WELCOME')
#создание кнопки Play
button_play = Button(nlo_settings, screen, 'Play')
#создание надписи при проигрыше
game_over = Game_over(screen, 'GAME OVER')
#создание надписи при выигрыше
you_win = Game_over(screen, 'CONGRATULATIONS!')
#создание кнопки повтора игры
try_again = Button(nlo_settings, screen, 'Try again')
#основной цикл игры
while True:
#выводит фоновое изображение на экран
screen.blit(fon, (0, 0))
#проверяет все события (нажатия клавиш, флаги и т.д.)
gf.check_events(korabl, nlo_settings, screen, pyli, button_play,
try_again, all_lifes)
#условия для запуска игровых действий
if nlo_settings.game_active:
if nlo_settings.korabl_view:
#обновления всех функций в зависимости от событий
sfera.update()
korabl.update()
gf.pyli_update(enemies, pyli, sfera, nlo_settings, bullets)
gf.life_control(screen, all_lifes, nlo_settings, bullets,
korabl)
gf.bullets_update(bullets, enemies, nlo_settings, screen,
korabl, sfera)
gf.enemies_update(enemies, nlo_settings, screen)
#обновление экрана
gf.update_screen(nlo_settings, screen, korabl, sfera, pyli, enemies,
bullets, all_lifes, button_play, game_over, try_again,
welcome, you_win)
def update(self, dt):
self.player.update(dt)
self.background.update(dt)
eneme_out_of_window = []
for enemieObj in ememies_list:
if (enemieObj.getX() < 10 or enemieObj.getX() > 500):
print(enemieObj.getX())
eneme_out_of_window.append(enemieObj)
enemieObj.update(dt)
for removeEneme in eneme_out_of_window:
ememies_list.remove(removeEneme)
# ememies_list.remove(enemieObj)
start = 0
end = 0
if (self.toggle == True):
start = 20
end = 40
self.toggle = False
else:
start = -40
end = -20
self.toggle = True
enemie = Enemies(posx=random.randint(0, 300), posy=185, velx=random.randint(start, end), vely=0,
image="goomba_1.png")
ememies_list.append(enemie)
def __init__(self, bzrc):
super(NonConformingAgent, self).__init__(bzrc)
self.invocations_before_update = 0
self.invocation_count = 0
self.boundaries = WorldBoundaries(bzrc)
self.enemies = Enemies(bzrc)
self.last_vector = Vec2d(0.0, 0.0)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.set_location(400, 100)
self.frame_rate = 1/60.0
self.player = GameObject( posx = 200, posy = 185 ,image = "Mario_Super.png")
self.background = BackgroundObject(posx = 0, posy = 0, image = "background_3.jpg")
#self.brick1 = BackgroundObject(posx=0, posy=0, image="brick1.png")
#self.brick2 = BackgroundObject(posx=862, posy=0, image="brick1.png")
#self.water = BackgroundObject(posx=625, posy=0, image="water.png")
self.enemie1 = Enemies(posx=random.randint(0, 300), posy=185, velx=random.randint(30, 50), vely=0,
image="goomba_1.png")
self.enemie2 = Enemies(posx=random.randint(0, 300), posy=185, velx=random.randint(-50, -30), vely=0,
image="goomba_1.png")
ememies_list.append(self.enemie1)
ememies_list.append(self.enemie2)
self.toggle = False
class Game(object):
def __init__(self, _states_manager):
self.road = Road()
self.player = Player()
self.enemies = Enemies()
self.ui = UI()
def update(self, _dt):
self.ui.update(_dt)
self.road.update(_dt, self.ui)
self.player.update(_dt, self.road.road)
self.enemies.update(_dt, self.player, self.ui)
if not self.player.alive:
self.road.stop()
def render(self, _screen):
self.road.render(_screen)
self.player.render(_screen)
self.enemies.render(_screen)
self.ui.render(_screen)
def play():
from menu import Menu
menu = Menu(screen)
#show menu before starting game.
menu.showMenu()
from player import Player
from bullet import Bullet
from enemies import Enemies
player = Player()
player.set_screen(screen)
to_update = player.create()
#draw player to screen immediately
pygame.display.update(to_update)
bullet = Bullet()
bullet.set_screen(screen)
enemies = Enemies()
enemies.set_screen(screen)
while player.is_alive():
to_update = []
pygame.event.pump()
key = pygame.key.get_pressed()
#key events that only need to be pressed once
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
menu.showMenu()
if event.key == pygame.K_SPACE:
player.fire(bullet, True)
if key[pygame.K_ESCAPE]:
sys.exit()
if key[pygame.K_RIGHT]:
to_update += player.move_right()
if key[pygame.K_LEFT]:
to_update += player.move_left()
if key[pygame.K_SPACE]:
player.fire(bullet, False)
frametime.start()
to_update += bullet.move(enemies, player)
to_update += enemies.move(bullet)
pygame.display.update(to_update)
#find how long it took to render this frame so we can adjust speeds
frametime.end()
#player died
player.game_over()
enemies.game_over()
bullet.game_over()
pygame.display.flip()
def main():
#SCREEN_SIZEの画面を作成
screen = pygame.display.set_mode(global_data.SCREEN_SIZE)
#タイトルバーの文字列をセット
pygame.display.set_caption(u"シューティングゲーム")
#FPSの取得
clock = pygame.time.Clock()
myship = MyShip(50,50)
enemies = Enemies()
while True:
#FPSを60に設定
clock.tick(60)
#背景色の設定
screen.fill((255,255,255))
# ***いろんな処理*** #
myship.move()
enemies.move()
enemies.reloadEnemy()
myship.draw(pygame,screen)
enemies.draw(pygame,screen)
#画面の更新
pygame.display.update()
for event in pygame.event.get():
if event.type == QUIT: pygame.quit(); sys.exit()
elif event.type == KEYDOWN:
if event.key == K_RIGHT: myship.direction["right"] = True
elif event.key == K_LEFT: myship.direction["left"] = True
if event.key == K_UP: myship.direction["up"] = True
elif event.key == K_DOWN: myship.direction["down"] = True
elif event.type == KEYUP:
if event.key == K_RIGHT: myship.direction["right"] = False
elif event.key == K_LEFT: myship.direction["left"] = False
if event.key == K_UP: myship.direction["up"] = False
elif event.key == K_DOWN: myship.direction["down"] = False
class NonConformingAgent(Agent):
"""Class handles all command and control logic for a teams tanks."""
def __init__(self, bzrc):
super(NonConformingAgent, self).__init__(bzrc)
self.invocations_before_update = 0
self.invocation_count = 0
self.boundaries = WorldBoundaries(bzrc)
self.enemies = Enemies(bzrc)
self.last_vector = Vec2d(0.0, 0.0)
def get_field_vector(self, tank):
if self.invocation_count < self.invocations_before_update:
self.invocation_count += 1
return self.last_vector, False
self.invocation_count = 0
self.invocations_before_update = random.randrange(100, 600)
print "updated invocations_before_update to %s" % self.invocations_before_update
print "checking for boundaries"
field_vec, shoot = self.boundaries.vector_at(tank.x, tank.y)
if field_vec.x != 0 or field_vec.y != 0:
print "avoiding boundaries"
print ""
self.last_vector = field_vec
return field_vec, False
print "checking for enemy tanks"
field_vec, shoot = self.enemies.vector_at(tank.x, tank.y)
if field_vec.x != 0 or field_vec.y != 0:
print "avoiding enemy tanks"
print ""
self.last_vector = field_vec
return field_vec, False
print "generating 'random' vector"
print ""
vx = random.uniform(-1.0, 1.0)
vy = random.uniform(-1.0, 1.0)
scale = random.uniform(-1.0, 1.0)
self.last_vector = Vec2d(vx, vy).normalized()
return self.last_vector * scale, False
class StraightAgent(Agent):
"""Class handles all command and control logic for a teams tanks."""
def __init__(self, bzrc):
super(StraightAgent, self).__init__(bzrc)
self.target_velocity = random.uniform(0.5, 1)
self.boundaries = WorldBoundaries(bzrc)
self.enemies = Enemies(bzrc)
def get_field_vector(self, tank):
field_vec, shoot = self.boundaries.vector_at(tank.x, tank.y)
if field_vec.x != 0 or field_vec.y != 0:
return field_vec, False
field_vec, shoot = self.enemies.vector_at(tank.x, tank.y)
if field_vec.x != 0 or field_vec.y != 0:
return field_vec, False
# if the tank has some velocity, then just use that
if tank.vx != 0 and tank.vy != 0:
return Vec2d(tank.vx, tank.vy), False
# just go in the direction that the tank is currently pointing
return Vec2d(math.cos(tank.angle), math.sin(tank.angle)), False
from shot import Shot
from enemies import Enemies
WIDTH=800
HEIGHT=600
TITLE="Space shooter game"
ICON="spacecrafticon.png"
scroll_speed = 2
player = Player()
spacecraft = SpaceShip("spacecraft", (400,480))
spacecraft.set_speed(4)
enemies = Enemies((WIDTH,HEIGHT), "enemies.dat")
# List to track shots
shots = []
# shot last fired timestamp - to ensure don't fire too many shots
shot_last_fired = 0
# time in seconds
time_between_shots = 0.5
scroll_position = 0
# spacecraft hit points
# positions relative to spacecraft centre which classes as a collide
spacecraft_hit_pos = [
(0,-40), (10,-30), (-10,-30), (13,-15), (-13,-15), (25,-3), (-25,-3),
(46,12), (-46,12), (25,24), (-25,24), (10,27), (-10,27), (0,27) ]
def create_enemy_list(self, grid):
enemies = Enemies(self.level, grid)
self.enemy_list = enemies.enemy_list
def main_game(val):
# variables used in this function
winings = 0
ships_missed = 0
bckg_y = 0
while val:
#main event loop
for event in pygame.event.get(): #user did something
if event.type == pygame.QUIT: #if user clicked close
done = True # to exit this loop
elif event.type == pygame.KEYDOWN:
if event.key == K_ESCAPE:
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
music_effect("blaster")
new_bullet = Bullet(screen, the_player)
bullets.add(new_bullet)
#controling a spaceship via the mouse
player_pos = pygame.mouse.get_pos()
pygame.mouse.set_visible(False) #to hide the mouse curser
the_player.update_me(player_pos)
# screen.blit(background, [0,0]):
#drawing and moving the background
moving_background(bckg_y)
bckg_y += 1
# rel_y = bckg_y % background.get_rect().height
# screen.blit(background, [0, rel_y - background.get_rect().height])
# if rel_y > 0:
# screen.blit(background2,(0, rel_y))
# bckg_y += 1
#screen.blit(player_ship, [x, y])
the_player.draw_me()
#screen.blit(enemy_ship, [100, 50])
for enemy_ship in enemy_list:
# # update the bad guy (based on where the player is)
enemy_ship.update_me(the_player)
# draw the bad guy
enemy_ship.draw_me()
if enemy_ship.beyond_screen():
ships_missed += 1
enemy_list.remove(enemy_ship)
print("ship missed")
#bullet portion
for bullet in bullets:
# update teh bullet location
bullet.update()
# draw the bullet on the screen
bullet.draw_bullet()
bullet_hit = groupcollide(bullets, enemy_list, True,
True) # when bullet hits the enemy
for bullet, enemy_ship in bullet_hit.items():
print("explosion")
music_effect("explosion")
enemy_ship[0].explosions(bullet)
winings += 1
if len(
enemy_list
) < 4: #if number of ships on the screen gets less than 4 - generate another ship
enemy_list.add((Enemies(screen, enemy_ship_selector())))
enemy_list.add((Enemies(screen, enemy_ship_selector())))
#ship_crash = groupcollide(player_group, enemy_list, True, True) #when enemy ship hits the player
#print ship_crash
text = font.render(
"Hits: " + str(winings), True, text_color
) # these 2 lines display a text for wins in the right top side of screen
screen.blit(text, [600, 50])
text = font.render(
"Ships missed: " + str(ships_missed), True, text_color
) # these 2 lines display a text for wins in the right top side of screen
screen.blit(text, [100, 50])
text = font.render(
"Press ESC to exit at any time", True, text_color
) # these 2 lines display a text for wins in the right top side of screen
screen.blit(text, [450, 750])
if ships_missed >= 1:
game_over()
pygame.display.flip() #update the screen with what we draw
clock.tick(80) #number of frames per second
pygame.quit()
enemyShip2 = "images/enemyShip2.png"
enemyShip3 = "images/enemyShip3.png"
enemyShip4 = "images/enemyShip4.png"
enemyShip5 = "images/enemyShip5.png"
def enemy_ship_selector():
en_index = random.randint(0, 4)
enemy_images_list = [
enemyShip1, enemyShip2, enemyShip3, enemyShip4, enemyShip5
]
enemy_ship_selector = enemy_images_list[en_index]
return enemy_ship_selector
enemy_ship = Enemies(screen, enemy_ship_selector())
#call function to select enemy ships combination
enemy_list = Group(
) #creates list of sprites which is managed by class 'Group'
for i in range(random.randint(3, 9)):
# this represents an enemy
enemy_list.add(enemy_ship)
new_bullet = Bullet(screen, the_player)
bullets = Group()
pygame.mixer.music.load("sounds/music.wav") #load game music
pygame.mixer.music.play(-1) #'-1' means play indefinetely
blaster = pygame.mixer.Sound(
'sounds/blaster.wav') #using Sound class does not interrupt main music
from pprint import pprint
from location import Location
from activities import Activities
from inventory import Inventory
from enemies import Enemies
loop = True
activities = Activities()
inventory = Inventory()
location = Location()
enemies = Enemies()
while loop:
print('You are at ' +
str(location.get_current_region_text(inventory, activities)))
if inventory.playerInventory['health'] <= 0:
print('You died!')
print('You had ' + str(inventory.playerInventory['EXP']) + ' EXP!')
loop = False
else:
print('Your health is ' + str(inventory.playerInventory['health']))
if inventory.playerInventory['house']:
if activities.inventory_new_recipes == 'Unchecked':
print('New crafting recipes learned!')
def __init__(self, _states_manager):
self.road = Road()
self.player = Player()
self.enemies = Enemies()
self.ui = UI()
def init_enemies(self):
self.enemies = Enemies(self, self.signal, self.game_settings)
class GameEvents(GameInterface, EventChecker):
"""
Считывание, проверка событий во время игровой сессии и запуск персонажей
Здесь еще частичное управление главного игрока, в будушем уберу отсюда.
"""
def __init__(self, game_settings):
super(GameEvents, self).__init__()
self.jesus = False
self.flag = False
self.game_settings = game_settings
self.set_frequency_render()
self.render_details()
# self.init_music()
def init_music(self):
self.music_back = MusicBackground()
self.music_back.start()
self.music_kill = MusicKill()
self.music_win = MusicWin()
self.music_shoot = MusicShootEnem()
def set_frequency_render(self):
self.timer = QBasicTimer()
self.timer.start(10, self)
def init_player(self):
self.stop_game = False
self.player = Player(self)
self.old_bullet_enem = None
self.old_bullet_pl = None
def init_enemies(self):
self.enemies = Enemies(self, self.signal, self.game_settings)
def init_signals(self):
self.signal = Signals()
self.signal.closed_signal.connect(self.close_game)
self.signal.stop_game_singal.connect(self.menu)
self.signal.restart_signal.connect(self.restart_game)
self.signal.reverse_bullet_player.connect(self.player.reverse_bullet)
def init_defenders(self):
self.defenders = Defenders(self, self.player, self.enemies)
def render_details(self):
self.init_player()
self.init_signals()
self.init_enemies()
self.init_values()
self.init_defenders()
def init_values(self):
self.boomm, self.traffic_left, self.traffic_right = False, False, False
def check_borders(self, direction):
x = self.player.player_label.x()
if direction == "left":
return x > 0
else:
return x < 780
def keyPressEvent(self, QKeyEvent):
"""
Фиксирование нажатых кнопокж.
Запуск потока пуль иг рока.
"""
if not self.stop_game and not self.flag:
even_key = QKeyEvent.key()
if even_key == Qt.Key_Right:
self.traffic_right = True
if even_key == Qt.Key_Left:
self.traffic_left = True
if even_key == Qt.Key_Space:
self.jesus = False
if self.player.bullet_flag:
self.signal.reverse_bullet_player.emit(True)
self.player.bullet_thread.start()
def keyReleaseEvent(self, event):
"""Фиксирование отжатых кнопок, во благо плавности"""
key = event.key()
if key == Qt.Key_Right and not event.isAutoRepeat(
) and self.traffic_right:
self.traffic_right = False
if key == Qt.Key_Left and not event.isAutoRepeat(
) and self.traffic_left:
self.traffic_left = False
def timerEvent(self, event):
"""Движение главного игрока
Проверка выстрелов в игрока"""
if not self.stop_game:
if self.traffic_left:
self.player.motion_player("left")
if self.traffic_right:
self.player.motion_player("right")
bullet_en = self.enemies.registr_bullet_hit_en(self.player)
self.game_event(bullet_en)
def game_event(self, bullet_en):
if bullet_en != self.old_bullet_enem and bullet_en and self.lives > 0 and not self.jesus:
self.jesus = True
self.old_bullet_enem = bullet_en
self.player.died_thread()
self.traffic_right, self.traffic_left = False, False
self.hide_dop_player(self.lives)
# self.music_kill.start()
self.count_lives()
if self.stop_game:
self.menu(False, False)
answer, killed_enemies = self.enemies.registr_bullet_hit_pl(
self.player)
if answer > 0:
# self.music_shoot.start()
self.signal.reverse_bullet_player.emit(False)
self.count_score(answer)
self.redrawing_score()
if killed_enemies:
self.menu(False, True)
def kill_threads(self):
self.defenders.kill_threads()
self.enemies.kill_threads()
def menu(self, draw_line, result_game):
if not self.flag:
self.flag = True
self.kill_threads()
if draw_line:
self.redrawing_line()
self.enemies.signal.hide_enemies_signal.emit()
self.draw_menu(result_game)
def music_event(self):
self.music_back.terminate()
def draw_menu(self, result_game):
# self.music_event()
self.close()
new_win = QuestionsInterface(self, self.signal, self.score,
result_game)
new_win.show()
def restart_game(self):
self.close_game()
os.system("python start.py")
def close_game(self):
self.close()
def closeEvent(self, event):
self.close_game()
from turret import Turret
from barriers import Barrier
from scoreboard import Scoreboard
enemy = "sprites/New Piskel.gif"
ship = "sprites/ship.gif"
screen = Screen()
screen.bgcolor("black")
screen.title("Space Invaders")
screen.addshape(enemy)
screen.addshape(ship)
screen.setup(width=600, height=600)
screen.tracer(0)
enemies = Enemies()
turret = Turret()
barriers = Barrier()
scoreboard = Scoreboard()
def check_player_collisions():
for enemy in enemies.enemy_list:
if turret.bullet:
if turret.bullet.distance(enemy) < 20:
enemies.kill(enemy)
turret.destroy()
scoreboard.point()
for brick in barriers.barrier_list:
def __init__(self, bzrc):
super(StraightAgent, self).__init__(bzrc)
self.target_velocity = random.uniform(0.5, 1)
self.boundaries = WorldBoundaries(bzrc)
self.enemies = Enemies(bzrc)
def main_game(val):
# variables used in this function
winings = 0
ships_missed = 0
bckg_y = 0
while val:
#main event loop
for event in pygame.event.get(): #user did something
if event.type == pygame.QUIT: #if user clicked close
done = True # to exit this loop
elif event.type == pygame.KEYDOWN:
if event.key == K_ESCAPE:
# sys.exit()
quit()
if event.key == pygame.K_p:
print "hitting button P"#just a test for now
pause()
elif event.type == pygame.MOUSEBUTTONDOWN:
music_effect("blaster")
new_bullet = Bullet(screen, the_player, bullet_selector(winings))
bullets.add(new_bullet)
#controling a spaceship via the mouse
player_pos = pygame.mouse.get_pos()
pygame.mouse.set_visible(False) #to hide the mouse curser
the_player.update_me(player_pos)
#drawing and moving the background
moving_background(bckg_y)
bckg_y += 1
#screen.blit(player_ship, [x, y])
the_player.draw_me()
#screen.blit(enemy_ship, [100, 50])
for enemy_ship in enemy_list:
# update the bad guy (based on where the player is)
enemy_ship.update_me(the_player)
# draw the bad guy
enemy_ship.draw_me()
if enemy_ship.beyond_screen():
ships_missed += 1
enemy_list.remove(enemy_ship)
print "ship missed"
#bullet portion
for bullet in bullets:
# update teh bullet location
bullet.update()
# draw the bullet on the screen
bullet.draw_bullet()
#remove bullet if beyond the screen
if bullet.beyond_screen():
bullets.remove(bullet)
print "bullet removed"
#enemy collision with bullet
bullet_hit = groupcollide(bullets, enemy_list, True, True) # when bullet hits the enemy
for bullet, enemy_ship in bullet_hit.iteritems():
print "explosion"
music_effect("explosion")
enemy_ship[0].explosions()
winings += 1
if len(enemy_list) < 4: #if number of ships on the screen gets less than 4 - generate another ship
enemy_list.add((Enemies(screen, enemy_ship_selector())))
enemy_list.add((Enemies(screen, enemy_ship_selector())))
player_crash = groupcollide(player_group, enemy_list, True, True) #when enemy ship hits the player
for player, enemy_ship in player_crash.iteritems():
print "player hit"
music_effect("explosion")
player.explosions()
game_over(winings)
print_text("Hits: " + str(winings), (600, 50), font, text_color)
print_text("Ships missed: " + str(ships_missed), (100, 50), font, text_color)
print_text("Press ESC to exit at any time", (450, 750), font, text_color)
if ships_missed >= 1:
game_over(winings)
pygame.display.update() #update the screen with what we draw
clock.tick(40) #number of frames per second
def new_room(self, last_exit):
self.room = Room(entrance=Room.OPPOSITE_DIRECTIONS[last_exit])
self.player.warp(self.room.get_player_spawn_point())
self.room.enemies = Enemies(self.enemy_count, speed=self.enemy_speed)
class Game:
def __init__(self):
self.map = Map()
self.towers = Towers(self.map)
self.enemies = Enemies(self.map, self.towers)
self.menu = Menu(self.map, self.towers, self.enemies, screen_width,
screen_height)
self.dragging_tower = False
self.round = 1
self.start_round()
def start_round(self, round=0):
difficulty = round + 3
self.enemies.new_round(difficulty=difficulty)
def round_traker(self):
if all([
enemy.deprecated == True or enemy.in_the_end == True
for enemy in self.enemies.enemies
]):
self.round += 1
self.start_round(round=self.round)
def on_mouse_motion(self, x, y, dx, dy):
self.map.on_mouse_motion(x, y, dx, dy)
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
self.menu.on_mouse_drag(x, y, dx, dy, buttons, modifiers)
def update(self, dt):
self.round_traker()
self.towers.update(dt, self.enemies)
self.enemies.update(dt, self.towers)
def user_text_draw(self):
self.enemies_left = pyglet.text.Label(
f'{len([enemy for enemy in self.enemies.enemies if not enemy.deprecated or enemy.in_the_end])} over {len(self.enemies.enemies)} enemies left',
font_name='Helvetica',
font_size=12,
x=window.width - 200,
y=window.height - 100,
anchor_x='center',
anchor_y='center')
self.enemies_left.draw()
self.round_nb = pyglet.text.Label(f'round {self.round}',
font_name='Helvetica',
font_size=12,
x=window.width - 200,
y=window.height - 120,
anchor_x='center',
anchor_y='center')
self.round_nb.draw()
def draw(self):
window.clear()
self.map.draw()
self.towers.draw()
self.enemies.draw()
self.menu.draw()
self.user_text_draw()
def on_mouse_press(self, x, y, button, modifiers):
self.menu.on_mouse_press(x, y)
def on_mouse_release(self, x, y, button, modifiers):
self.menu.on_mouse_release(x, y)
def __init__(self, level):
self.enemies = Enemies(characterlevel=level)
def run(self):
# Game clock
clock = pygame.time.Clock()
# enemy Spawner
Enems_pos = [50, 200, 350, 500, 650, 750]
Enem = []
for i in range(5):
Enem.append(Enemies(Enems_pos[i], -100, 1, self.window))
# Player variable
player = Player(self.window, (width * 0.5), (height * 0.5))
# Game loop
isRunning = True
# Player Score
dodged = 0
# player health
health = 100
# Bullets list
bullets = []
enem_bullets = []
time0 = tm.time()
# main game loop
while isRunning:
# Check if bullet is out of bounds
for bullet in bullets:
if bullet.y < -100:
bullets.pop(bullets.index(bullet))
else:
bullet.y -= bullet.vel
for bullet in enem_bullets:
if bullet.y < -100:
enem_bullets.pop(bullets.index(bullet))
else:
bullet.y += bullet.vel
# Game events starts here
for event in pygame.event.get():
if event.type == pygame.QUIT:
isRunning = False
self.app_quit()
# key is pressed
if event.type == pygame.KEYDOWN:
# move left
if event.key == pygame.K_LEFT:
player.acclerate(-5)
# move right
elif event.key == pygame.K_RIGHT:
player.acclerate(5)
# move up
elif event.key == pygame.K_UP:
player.acclerate(0, -5)
# move down
elif event.key == pygame.K_DOWN:
player.acclerate(0, 5)
# fire bullets
elif event.key == pygame.K_SPACE:
fire(self.window, player, bullets)
# key is released
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT or event.key == pygame.K_UP or event.key == pygame.K_DOWN:
player.acclerate(0, 0)
# Game Events ends here
# fill the screen with white color
#self.window.fill(white)
self.window.blit(background, (0, 0))
# Draw the player
player.draw()
for bullet in enem_bullets:
bullet.draw()
# Draw bullets
for bullet in bullets:
bullet.draw()
# Spawn The enemeis
for i in Enem:
i.Spawn()
i.move()
if tm.time() - time0 > 3: # Shoot once every 3 seconds
time0 = tm.time()
i.fire(self.window, enem_bullets)
# Move players and enemies
player.move()
# Show fps
show_fps(clock, self.window)
#message_display(f"dodged: {dodged}" , 70 , 15 ,25, white , self.window)
hitbox = player.get_hitbox()
# draw the player healthbar
draw_healthbar(self.window, player.x, (hitbox[1] + hitbox[3]) + 15,
health, 10)
# check if player is out of bounds
if player.x > width - carw or player.x < 0:
self.Crash()
for bullet in enem_bullets:
hit = bullet.get_hitbox()
pl_bullet_col = self.detect_collisions(hitbox, hit)
if pl_bullet_col:
health -= 10
enem_bullets.pop(enem_bullets.index(bullet))
# bullet collision
for enemy in Enem:
# enemy hitbox
enem_hitbox = enemy.get_hitbox()
collsion = self.detect_collisions(hitbox, enem_hitbox)
# player collsion
if collsion:
# check if player health is Zero or below
if health <= 0:
self.Crash()
else:
enemy.y = 0 - enemy.h
enemy.x = random.randrange(0, width)
health -= 10
for bullet in bullets:
bullet_hitbox = bullet.get_hitbox()
# collision detection function
collsion_bullet = self.detect_collisions(
bullet_hitbox, enem_hitbox)
pl_col = self.detect_collisions(hitbox, bullet_hitbox)
if collsion_bullet:
# reset enemy position
enemy.y = 0 - enemy.h
enemy.x = random.randrange(0, width)
bullets.pop(bullets.index(bullet))
pygame.display.update()
clock.tick()
