def handle_input(event_list) -> bool:
global current_level, score, is_game_over, is_game_beaten, music_on
for event in event_list:
if event.type == KEYDOWN:
if event.key == K_m:
if music_on:
music_on = False
sound_music.stop()
else:
music_on = True
sound_music.play(-1)
save_game()
elif is_game_over:
if music_on and is_game_beaten:
sound_music.play(-1)
score = 0
is_game_over = False
is_game_beaten = False
current_level = level.LEVEL_ONE
level.load(current_level)
player.initialize_position()
elif event.type == QUIT:
return False
if not is_game_over:
player.handle_input(event_list)
return True
def download_level(self):
size = 0
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
logger.info('connecting to {}'.format(self.addr))
try:
sock.connect(self.addr)
logger.info('connected; requesting {}'.format(self.name))
sock.sendall(self.name)
with open(self.name, 'wb') as f:
recv_size = 1024
while True:
response = sock.recv(recv_size)
size += len(response)
if not response:
break
f.write(response)
except IOError:
logger.exception('failed to read from remote')
finally:
sock.close()
level_obj = level.load(self.name)
if level_obj:
logger.info('Got {}; size {} bytes'.format(self.name, size))
def cmd():
self.callback(level_obj)
self.handler.put(cmd)
else:
logger.warning(
'Tried to download {} but failed (got {} bytes)'.format(
self.name, size))
os.remove(self.name)
def main():
# Trying to make the menu/game multiresolution capable, might not pan out
res = [(1280, 720), (1920, 1080), (2560, 1440)]
resolution = 0
screen = pygame.display.set_mode(res[resolution])
pygame.display.set_caption("Zacharaiah")
play_btn = Button('images/buttons/play.png', 'images/buttons/playHover.png', (1280 * .175, 720 * .417))
settings_btn = Button('images/buttons/settings.png', 'images/buttons/settingsHover.png', (1280 * .511, 720 * .417))
menuFont = pygame.font.Font('freesansbold.ttf', 32)
title = menuFont.render('Zacharaiah', True, (0, 0, 0))
titleObj = title.get_rect()
titleObj.center = (1280 * .5), (720 * .1)
while True:
mouseClick = False
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
pygame.quit()
sys.exit()
elif event.type == MOUSEBUTTONUP:
mouseClick = True
screen.fill((0, 0, 0))
play_btn.reset_img()
settings_btn.reset_img()
if play_btn.rect.collidepoint(pygame.mouse.get_pos()):
play_btn.img_hover()
if settings_btn.rect.collidepoint(pygame.mouse.get_pos()):
settings_btn.img_hover()
#Load the overworld upon clicking 'Play' button
if play_btn.rect.collidepoint(pygame.mouse.get_pos()) and mouseClick:
level.load()
if settings_btn.rect.collidepoint(pygame.mouse.get_pos()) and mouseClick:
settings.settingsMenu('bar')
pygame.draw.rect(screen, (0, 255, 0), (((1280 - 200) * .5), (720 * .1) - 25, 200, 50))
screen.blit(title, titleObj)
screen.blit(play_btn.image, play_btn.rect)
screen.blit(settings_btn.image, settings_btn.rect)
pygame.display.update()
def EVT_tick(self,event):
if self.delay:
self.delay -= 1
else:
filename = Campaign.next(self.level.replace('\\','/'))
if filename:
lvl = level.load(filename)
level.save(lvl,'save.lvl')
self.quit(GameState(lvl))
else:
self.quit(Ending())
def nextLevel(self):
self.level += 1
try:
self.invaders, self.asteroids = level.load('data/level'+str(self.level)+'.dat', self)
except:
return False
self.invaders = pygame.sprite.Group(self.invaders)
self.asteroids = pygame.sprite.Group(self.asteroids)
self.explosions = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.player = pygame.sprite.GroupSingle(Spaceship(self, 12 * 32 + 16, 18 * 32 + 16))
return True
def __init__(self, screen, lvl=None):
State.__init__(self, screen)
pygame.mixer.music.stop()
self.jkbx = jukebox.Jukebox()
self.jkbx.stop_song()
self.jkbx.load_song('sisters')
self.jkbx.set_song_volume(0.2)
self.jkbx.play_song('sisters', 10)
pygame.mouse.set_visible(False)
self.cursor = pygame.image.load(os.path.join('data', 'crosshair.bmp'))
self.cursor.set_colorkey((0,0,0))
if lvl != None:
lvl = level.load(lvl)
else:
lvl = lvl.new(5,5)
self.background = pygame.Surface((len(lvl['tiles'])*20,
len(lvl['tiles'][0])*20))
self.game_window = pygame.Surface((800,600))
self.tiles = sprites.Group()
y = 0
for row in lvl['tiles']:
x = 0
for t in row:
t.rect = pygame.Rect((x,y),(20,20))
t.add(self.tiles)
x += 20
y += 20
self.tiles.draw(self.background)
self.level = self.background.copy()
self.sprites = sprites.Group()
self.hero = sprites.hero(lvl['hero'], self.sprites)
self.hero.rect = pygame.Rect(lvl['hero'], self.hero.rect.size)
self.enemies = pygame.sprite.Group()
for enemy in lvl['enemies']:
pos = enemy.pos
enemy = sprites.Howitzer([self.sprites, self.enemies])
enemy.rect.center = pos
enemy.target = self.hero
self.display = scrolling.scrolling_display(self.level,
self.game_window, (0,0))
self.FX = effects.Effects(self.screen, self.jkbx, self.background)
self.tile_rects = [t.rect for t in self.tiles]
self.HUD = HUD()
self.paused = False
self.won = False
self.lost = False
self.lose_delay = -1
self.win_delay = -1
self.old_time = pygame.time.get_ticks()
def load_level(self, path):
if len(path) > 0:
level_obj = level.load(path)
if level_obj is None:
return False
self.state.load_level(level_obj)
for entity in level_obj.dynamic_entities:
self.add_entity(entity, 0)
self.do_load(level_obj)
logger.info('Loaded level at {}'.format(path))
self._level_name = path
return True
def __init__(self,lvl=None):
State.__init__(self)
if lvl == None:
self.level = level.load(Campaign.next())
else:
self.level = lvl
self.bg = pygame.sprite.Group(self.level.s)
self.selected = None
self.audio = Audio()
self.music = Music()
self.music.volume = 1
self.audio.volume = 0.5
self.alarm = 0
self.music.stop(500)
self.music.play('data/music/play.ogg',-1)
self.playing = True
def load_lvl(num_lvl):
if (globals.Jour):
pygame.mixer.music.load('assets/sounds/theme_day.mp3')
else:
pygame.mixer.music.load('assets/sounds/theme_night.mp3')
pygame.mixer.music.play(-1)
pygame.mixer.music.set_volume(0.03)
mobs.mobs = []
globals.LVL = level.load(num_lvl)
globals.MAP = level.toTileMap(globals.LVL)
spawnTile = level.getSpawn(globals.MAP)
spawnX = spawnTile.x
spawnY = spawnTile.y
globals.changeView(spawnX, spawnY)
fade.fade()
globals.PLAYER.load(spawnX, spawnY)
globals.LVL_CHANGED = False
if globals.LOGS:
level.cli(globals.LVL)
fade.fade()
def setup(self, levelname):
sounds.load()
self.lives = settings.STARTING_LIVES
self.update_labels()
self.level = level.load(levelname)
self.track = track.Track()
self.track.add_tracks(self.level.tracks)
self.ruby_list = entity.ObjectList({"default": ruby.Ruby})
self.ruby_list.add(self.level.rubies)
self.obstacle_list = entity.ObjectList({"default": obstacle.Obstacle, "exit": obstacle.EndLevel})
self.obstacle_list.add(self.level.obstacles)
self.spawn_points = entity.ObjectList({"default": obstacle.Spawn})
self.spawn_points.add(self.level.spawn)
self.entities.extend(self.spawn_points.objects)
self.objects = [self.ruby_list, self.obstacle_list]
self.create_cart()
self.viewport.reset(Rect(self.cart.gp.x, self.cart.gp.y - self.height / 2, self.width, self.height))
# now check the level contents.
self.bg = scene.Background(self.level.layers, self.viewport)
def _on_init_level(self, msg_id, data, addr):
msg = messages.InitLevelMsg
msg.unpack(data)
self._player_id = msg.player_id
logger.info('init level {}. player id is {}'.format(msg.level_path, self._player_id))
# clear old state
self._states.clear()
self._last_server_time = 0
l = level.load(msg.level_path)
if not l:
client = download_client.DownloadClient(
(self._remote_address[0], 4444),
msg.level_path,
self.handler,
self._init_level)
t = threading.Thread(target=client.download_level)
t.daemon = True
t.start()
else:
self._init_level(l)
yield from level.top(message=message, client=client)
def save():
global timer
if time.time() - timer > 3600:
level.save()
commands.save()
timer = time.time()
logging.debug("Saving...")
if __name__ == "__main__":
logging.basicConfig(filename=config.LOG_PATH,
filemode='w',
level=logging.DEBUG)
timer = time.time()
commands.load()
level.load()
permission.load()
loop = asyncio.get_event_loop()
try:
loop.run_until_complete(client.start(config.BOT_TOKEN))
except (KeyboardInterrupt, Exception):
loop.close()
client.logout()
running = False
finally:
level.save()
commands.save()
def init_game(self, level_name, keep_config=False, keep_velocity=False):
self.init_pre_load(keep_config)
level.load(level_name, keep_config, keep_velocity)
self.init_post_load()
level.save()
def EVT_tick(self,event):
if self.delay:
self.delay -= 1
else:
lvl = level.load(self.level)
self.quit(GameState(lvl))
def main():
global current_level, score, high_score, is_game_over, game_over_scrim, player
pg.font.init()
pg.display.init()
pg.display.set_caption(WINDOW_CAPTION)
pg.mixer.init(44100, -16, 2, 64)
clock = pg.time.Clock()
screen = pg.display.set_mode(WINDOW_SIZE)
load_assets()
load_game()
level.load(current_level)
sound_ambient.play(-1)
if music_on:
sound_music.play(-1)
player = Player()
while handle_input(pg.event.get()):
if player.dead:
game_over()
if player.promoted:
player.promoted = False
current_level += 1
if level.load(current_level):
player.initialize_position()
else:
# There are no more levels
game_over(success=True)
# Draw the level's background
screen.blit(level.background, [0, 0])
# Draw the level's collectibles
if player.active():
collected = pg.sprite.spritecollide(player, level.collectibles,
False)
for collectible in collected:
score += collectible.collect()
if score > high_score:
high_score = score
save_game()
for collectible in level.collectibles.sprites():
collectible.draw(screen)
# Draw the level's enemies
for enemy in level.enemies.sprites():
enemy.update()
collision_point = pg.sprite.collide_mask(player, enemy)
if collision_point is not None:
# Player hit an enemy
player.die(collision_point)
enemy.draw(screen)
player.draw(screen)
draw_ui(screen)
pg.display.flip()
clock.tick(WINDOW_FRAME_RATE)
pg.quit()
def _is_valid_level(self, name):
return level.load(name) is not None
def rungame():
# init all stuff
init()
# yay! play the game!
running = True
timer.startTiming()
lvl = level.load("rageons3")
lvl.scroller.w = screensize[0] / 32 + 1
lvl.scroller.h = screensize[1] / 32 + 1
plr = sprite.Sprite("player")
plr.w = 1.0
plr.h = 0.9
plr.x, plr.y = lvl.plrstartx, lvl.plrstarty
plr.health = 100
possiblepositions = [(1, 1), (1.5, 1), (2.5, 1), (3, 1), (3.5, 1), (4, 1), (4.5, 1),
(1, 8)]
possibleenemys = ["enemy", "enemy2", "enemy3", "enemy4"]
#possiblepositions = []
#for y in range(lvl.h):
# for x in range(lvl.w):
# if lvl.collision[lvl.level[y][x]] == 0:
# possiblepositions.append((x, y))
# print lvl.level[y][x], (x, y)
# TODO: find out why the mabla this doesn't work!
enemies = lvl.lvlenemies
pain = []
ppain = []
for ne in enemies:
ne.vx = 0.5
ppain.append(damageArea.RectDamage(ne.x, ne.y, ne.w, ne.h, ne.vx, ne.vy, -1, 10))
ne.damager = ppain[-1]
timer.gameSpeed = 1
lasthithp = 0
sentence = ""
sentencestrength = 1
mode = 0
textthing = font.Text("")
while running:
timer.startFrame()
for event in pygame.event.get():
if event.type == QUIT:
running = False
if mode == 1:
if event.type == KEYDOWN:
if K_a <= event.key <= K_z:
if event.key == K_h:
sentence += "'"
else:
sentence += chr(ord('a') + event.key - K_a)
textthing.renderText(sentence + "_")
textthing.rgba = (1, 1, 1, 1)
elif event.key == K_SPACE:
sentence += " "
textthing.renderText(sentence + "_")
textthing.rgba = (1, 1, 1, 1)
elif event.key == K_BACKSPACE:
sentence = sentence[:-1]
textthing.renderText(sentence + "_")
textthing.rgba = (1, 1, 1, 1)
if len(sentence) == 0:
mode = 0
textthing.renderText(sentence)
elif event.key == K_RETURN:
mode = 0
sentencestrength = 1
textthing.renderText(sentence)
else:
if event.type == KEYDOWN:
if event.key == K_s:
mode = 1
sentence = ""
textthing.renderText(sentence + "_")
textthing.rgba = (1, 1, 1, 1)
if event.key == K_SPACE:
if plr.vx > 0:
x = plr.x + plr.w
sa = pi / -2
ea = pi / 2
else:
x = plr.x
sa = pi / 2
ea = pi / 2 * 3
if plr.physics == 'standing':
plr.vy -= 2
np = damageArea.ArcDamage(x, plr.y + plr.h / 2.0, plr.vx, plr.vy, 0.75, sa, ea, 0.25, 10 + len(sentence) * sentencestrength * 3)
pain.append(np)
sentencestrength *= 0.75
textthing.rgba = (1, 1, 1, sentencestrength)
if mode == 0:
if pygame.key.get_pressed()[K_UP]:
if plr.physics == 'standing':
plr.vy = -6.0
elif plr.physics == 'falling' and plr.vy < 0:
plr.vy *= 1.0 - timer.curspd
if pygame.key.get_pressed()[K_LEFT]:
if plr.state != 'ouch':
if plr.physics == 'standing':
plr.vx = max(-3, plr.vx - 10 * timer.curspd)
else:
plr.vx = max(-3, plr.vx - 5 * timer.curspd)
elif pygame.key.get_pressed()[K_RIGHT]:
if plr.state != 'ouch':
if plr.physics == 'standing':
plr.vx = min(3, plr.vx + 10 * timer.curspd)
else:
plr.vx = min(3, plr.vx + 5 * timer.curspd)
else:
if plr.vx != 0:
plr.vx *= 0.99
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
plr.move()
for p in ppain:
p.move()
if p.lifetime == 0:
ppain.remove(p)
if p.check(plr):
p.hit(plr)
for p in pain:
p.move()
if p.lifetime == 0:
pain.remove(p)
for en in enemies:
en.move()
for p in pain:
if p.check(en):
p.hit(en)
lasthithp = en.health
if en.state == 'dead':
enemies.remove(en)
lvl.scroller.centerOn(plr.x, plr.y, timer.curspd / 2)
glPushMatrix()
# do stuff
lvl.scroller.scroll()
lvl.draw()
glPushMatrix()
#lvl.scroller.scroll()
plr.draw()
for en in enemies:
en.draw()
for p in pain:
p.draw()
glPopMatrix()
glPopMatrix()
glPushMatrix()
glLoadIdentity()
glTranslatef(5, 5, 0)
glScalef(1./32, 1./32, 1)
textthing.draw()
glPopMatrix()
# enemy HP
glDisable(GL_TEXTURE_2D)
glColor4f(1.0, 1.0, 1.0, 1.0)
glBegin(GL_QUADS)
glVertex2f(0, 0)
glVertex2f(2, 0)
glVertex2f(2, 0.2)
glVertex2f(0, 0.2)
glColor4f(1.0, 0.0, 0.0, 1.0)
glVertex2f(0.05, 0.05)
glVertex2f(0.05 + lasthithp / 100.0 * 1.9, 0.05)
glVertex2f(0.05 + lasthithp / 100.0 * 1.9, 0.15)
glVertex2f(0, 0.15)
glEnd()
# player HP
glColor4f(1.0, 1.0, 1.0, 1.0)
glBegin(GL_QUADS)
glVertex2f(3, 0)
glVertex2f(5, 0)
glVertex2f(5, 0.2)
glVertex2f(3, 0.2)
glColor4f(1.0, 0.0, 0.0, 1.0)
glVertex2f(3.05, 0.05)
glVertex2f(3.05 + plr.health / 100.0 * 1.9, 0.05)
glVertex2f(3.05 + plr.health / 100.0 * 1.9, 0.15)
glVertex2f(3, 0.15)
glEnd()
pygame.display.flip()
timer.endFrame()
# exit pygame
pygame.quit()
def EVT_MouseButtonDown(self, event):
if self.selected == 'Create New':
self.quit(NewLevel(self.screen))
elif self.selected != None:
self.quit(LevelEditor(self.screen, level.load(self.selected),
self.selected))
def __init__(self, width=1280, height=720):
super(Game, self).__init__(width, height)
# load first level
self.cubes = level.load('1.lvl', self.cube_size)
def open(self):
path = gui.open_file(type_list = ['yaml'])
if path == None: return
level.load(path)
def EVT_Menu_Continue(self,event):
self.quit(GameState(level.load('save.lvl')))
def open_3(self, dt=0, path=None):
self.busy = False
if path != None:
level.load(path)
def main(level_file):
clock = events.dispatcher('Clock')
keyboard = events.dispatcher('Keyboard')
pygame.init()
pygame.display.gl_set_attribute(pygame.GL_ALPHA_SIZE, 8)
pygame.display.set_mode((1000, 600), pygame.OPENGL | pygame.DOUBLEBUF | pygame.RESIZABLE)
handle_resize(1000, 600)
screen_center = (500, 300)
camera_offset = 230
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glEnable(gl.GL_BLEND)
gl.glBlendEquation(gl.GL_FUNC_ADD)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glClearColor(0, 0, 0, 1)
tick_event = pygame.event.Event(constants.TICK)
datadir = find_datadir()
loader = pyglet.resource.Loader(datadir)
player1 = viking(datadir, clock, keyboard,
pygame.K_a, pygame.K_d, pygame.K_w, pygame.K_j)
player2 = viking(datadir, clock, keyboard,
pygame.K_LEFT, pygame.K_RIGHT, pygame.K_UP, pygame.K_RETURN)
player2.location[0] = 900
entities = [player1, player2]
scream = pygame.mixer.Sound(os.path.join(datadir, 'wilhelm.wav'))
background = load_sprite(datadir, 'background')
backgroundbuf = GLBuffer(4 * 4, numpy.float32, gl.GL_STATIC_DRAW)
backgroundbuf[:] = background.xyuv
if level_file is None:
walls = [components.hitbox((-5, -5), (10, 610)),
components.hitbox((995, -5), (10, 610)),
components.hitbox((-5, 595), (1010, 5)), ]
else:
walls = level.load(level_file)
for w in walls:
numpy.round(w.point, out=w.point)
numpy.round(w.size, out=w.size)
walls_tlbr = numpy.empty((2, len(walls), 2))
walls_tlbr[0] = [w.point for w in walls]
walls_tlbr[1] = [w.point + w.size for w in walls]
# vertex positions for walls
quads = numpy.empty((len(walls), 4, 2), dtype=numpy.float32)
quads[:, 0, :] = [w.point for w in walls]
quads[:, 2, :] = [w.size for w in walls]
quads[:, 2, :] += quads[:, 0, :]
quads[:, 1, 0] = quads[:, 0, 0]
quads[:, 1, 1] = quads[:, 2, 1]
quads[:, 3, 0] = quads[:, 2, 0]
quads[:, 3, 1] = quads[:, 0, 1]
wallbuf = GLBuffer(quads.size, numpy.float32, gl.GL_STATIC_DRAW)
wallbuf[:] = quads
del quads
# contains vertex and texture positions for sprites
entitybuf = GLBuffer(dtype=numpy.float32)
# walls program
wallprog = shaders.wall()
spriteprog = shaders.sprite()
dragonprog = shaders.psycho()
dragonpalette = load_texture(os.path.join(datadir, 'wallpalette.png'), dimensions=1)
dragonsprite_scales = load_sprite(datadir, 'dragon_scales')
dragonsprite_contours = load_sprite(datadir, 'dragon_contours')
dragonbuf = GLBuffer(4 * 4, numpy.float32, gl.GL_STATIC_DRAW)
dragonbuf[:] = dragonsprite_scales.xyuv + (-100, 145, 0, 0)
contourbuf = GLBuffer(4 * 4, numpy.float32, gl.GL_STATIC_DRAW)
contourbuf[:] = dragonsprite_contours.xyuv + (-100, 145, 0, 0)
debug_draw = False
pause = False
do_frame = False
ticks_done = 0
while True:
start = time.clock()
key_events = []
resize_event = None
for event in pygame.event.get():
if event.type == pygame.QUIT:
return 0
elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
key_events.append(event)
elif event.type == pygame.VIDEORESIZE:
resize_event = event
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
return 0
if event.key == pygame.K_F2:
debug_draw = not debug_draw
elif event.key == pygame.K_F3:
entities.append(sheep(datadir, clock))
elif event.key == pygame.K_F4:
entities.append(drake(datadir, clock))
elif event.key == pygame.K_F5:
entities.append(floaty_sheep(datadir, clock))
elif event.key == pygame.K_p:
pause = not pause
elif event.key == pygame.K_PERIOD and pause:
do_frame = True
if resize_event:
handle_resize(resize_event.w, resize_event.h)
screen_center = (resize_event.w // 2, resize_event.h // 2)
background.xyuv[:, :2] = [[0, 0], [0, resize_event.h],
[resize_event.w, resize_event.h], [resize_event.w, 0]]
backgroundbuf[:] = background.xyuv
if (not pause) or do_frame:
for event in key_events:
keyboard.dispatch(event)
location = components.entity.location
delta = numpy.array(location)
motion_a = components.entity.motion_a
motion_v = components.entity.motion_v
active_tl = components.entity.active_tl
active_br = components.entity.active_br
passive_tl = components.entity.passive_tl
passive_br = components.entity.passive_br
instances = components.entity._all[:components.entity._nentities]
do_translate = components.entity.translate_all
GROUNDED = intern('grounded')
motion_a[:] = (0, constants.G)
clock.dispatch(tick_event)
for thing in entities:
thing.tags.discard(GROUNDED)
motion_v[:] += motion_a
collisions.resolve_passive_active_collisions(instances, active_tl, active_br, passive_tl, passive_br)
attempts = 0
adjust_significant = True
rppc = collisions.resolve_passive_passive_collisions
rwc = collisions.resolve_wall_collisions
grounded_mask = numpy.zeros((len(instances),), dtype=bool)
stop = numpy.empty((len(instances),2), dtype=bool)
adjust, sides = rwc(motion_v, passive_tl, passive_br, walls_tlbr[0], walls_tlbr[1])
numpy.logical_or.reduce(sides.reshape(-1, 2, 2), out=stop, axis=2)
motion_v[stop] = 0
do_translate(motion_v[:])
while attempts < 20 and adjust_significant:
adjust, sides, done_impulse = rppc(motion_v, passive_tl, passive_br)
grounded_mask |= sides[:,3]
adjust *= 0.5
do_translate(adjust)
adjust_significant = not numpy.allclose(adjust, 0, atol=0.125)
adjust_significant |= done_impulse > 0.125
del adjust, sides
adjust, sides = rwc(motion_v, passive_tl, passive_br, walls_tlbr[0], walls_tlbr[1])
adjust_significant |= not numpy.allclose(adjust, 0, atol=0.5)
do_translate(adjust)
numpy.logical_or.reduce(sides.reshape(-1, 2, 2), out=stop, axis=2)
motion_v[stop] = 0
grounded_mask |= sides[:,3]
attempts += 1
for thing in numpy.compress(grounded_mask, instances):
thing.tags.add(GROUNDED)
do_frame = False
ticks_done += 1
dead = []
gl.glLoadIdentity()
gl.glEnableVertexAttribArray(0)
gl.glUseProgram(spriteprog.id)
gl.glBindTexture(gl.GL_TEXTURE_2D, background.texid)
spriteprog['texture'] = 0
with backgroundbuf.bound:
gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
gl.glDrawArrays(gl.GL_TRIANGLE_FAN, 0, 4)
# Now move camera
camera_location = (screen_center - numpy.round(entities[0].location)) + (0, camera_offset)
gl.glTranslated(camera_location[0], camera_location[1], 0.0)
for thing in entities:
if thing.hitpoints <= 0 or thing.location[1] > 10000:
dead.append(thing)
continue
for thing in dead:
scream.play()
if thing.name == 'Player':
thing.hitpoints = 100
thing.location[:] = (500, -10)
thing.motion_v[:] = 0
if thing.physics is not None:
thing.physics.last_position[:] = thing.location
else:
entities.remove(thing)
thing.dispose()
xyuv = numpy.empty((4, 4), dtype=numpy.float32)
texid = [0] * len(entities)
with entitybuf.bound:
for n, thing in enumerate(entities):
xyuv[:] = thing.graphics.sprite.xyuv
xy = xyuv[:, 0:2]
xy[:] += thing.graphics.anchor
xy[:] += thing.location
numpy.round(xy, out=xy)
offset = n * 16
entitybuf[offset:] = xyuv
texid[n] = thing.graphics.sprite.texid
#print('Loaded data for entity', n, xyuv, 'texid', texid[n])
gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
for n, t in enumerate(texid):
gl.glBindTexture(gl.GL_TEXTURE_2D, t)
gl.glDrawArrays(gl.GL_TRIANGLE_FAN, n * 4, 4)
# draw walls
gl.glUseProgram(wallprog.id)
wallprog['color'] = (162.0/255.0, 153.0/255.0, 118.0/255.0, 1.0)
with wallbuf.bound:
gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
gl.glDrawArrays(gl.GL_QUADS, 0, len(walls) * 8)
# draw some shaders
gl.glUseProgram(dragonprog.id)
gl.glBindTexture(gl.GL_TEXTURE_2D, dragonsprite_scales.texid)
gl.glActiveTexture(gl.GL_TEXTURE0 + 1)
gl.glBindTexture(gl.GL_TEXTURE_1D, dragonpalette)
gl.glActiveTexture(gl.GL_TEXTURE0)
dragonprog['texture'] = 0
dragonprog['palette'] = 1
dragonprog['perturb'] = (ticks_done % 1024) / 128
dragonprog['shift'] = ticks_done / 600
with dragonbuf.bound:
gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
gl.glDrawArrays(gl.GL_TRIANGLE_FAN, 0, 4)
# now draw the rest of the f****n' dragon
gl.glUseProgram(spriteprog.id)
gl.glBindTexture(gl.GL_TEXTURE_2D, dragonsprite_contours.texid)
spriteprog['texture'] = 0
with contourbuf.bound:
gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, gl.GL_FALSE, 0, 0)
gl.glDrawArrays(gl.GL_TRIANGLE_FAN, 0, 4)
if debug_draw:
gl.glUseProgram(wallprog.id)
wallprog['color'] = (0.89, 0.89, 0.89, 1.0)
quads = numpy.zeros((len(entities), 4, 2), dtype=numpy.float32)
quads[:, 0, :] = components.entity.passive_tl
quads[:, 2, :] = components.entity.passive_br
quads[:, 1, 0] = quads[:, 0, 0]
quads[:, 1, 1] = quads[:, 2, 1]
quads[:, 3, 0] = quads[:, 2, 0]
quads[:, 3, 1] = quads[:, 0, 1]
gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, quads.ctypes.data)
gl.glDrawArrays(gl.GL_QUADS, 0, quads.size // 2)
gl.glColor3f(1, 1, 1)
gl.glEnable(gl.GL_TEXTURE_2D)
#screen.fill((120, 50, 50), pygame.Rect(0, 10, player1.hitpoints * 2, 10))
#screen.fill((120, 50, 50), pygame.Rect(1000 - player2.hitpoints * 2, 10, player2.hitpoints * 2, 10))
pygame.display.flip()
delta = time.clock() - start
if delta < constants.FRAME:
time.sleep(constants.FRAME - delta)
def launch(self,lvl):
lvl = 'data/levels/' + self.selected
self.quit(GameState(level.load(lvl)))
dungeon_game_logger.logger.warning('Wrong input! It should be `1` or `2`')
return int(option)
save_exists = os.path.isfile('save.pickable')
option = choose_option() if save_exists else 1
if option == 1:
while True:
size_str = input('Enter level size (N x N): ')
if size_str.isnumeric() and int(size_str) >= 5:
size = int(size_str)
break
dungeon_game_logger.logger.warning('Wrong input! It should be integer >= 5 number')
lvl = level.generate_level(size)
lvl_is_valid = level.validate(lvl)
player_x, player_y = dungeon_game.spawn_player(lvl)
elif option == 2:
lvl, player_x, player_y = level.load()
player_x, player_y = dungeon_game.loop(lvl, player_x, player_y)
level.print_level(lvl, player_x, player_y)
