class Application(object):
def __init__(self):
self.win = None
self.music = None
self.vsync = (
not settings.has_option('all', 'vsync') or
settings.getboolean('all', 'vsync')
)
def launch(self):
self.win = Window(
width=1024, height=768,
vsync=self.vsync,
visible=False)
self.win.set_mouse_visible(False)
GameItem.win = self.win
load_sounds()
self.music = Music()
self.music.load()
self.music.play()
keystate = key.KeyStateHandler()
self.win.push_handlers(keystate)
game = Game(keystate, self.win.width, self.win.height)
handlers = {
key.M: self.toggle_music,
key.F4: self.toggle_vsync,
key.ESCAPE: self.exit,
}
game.add(KeyHandler(handlers))
render = Render(game)
render.init(self.win)
game.startup(self.win)
self.win.set_visible()
pyglet.app.run()
def toggle_vsync(self):
self.vsync = not self.vsync
self.win.set_vsync(self.vsync)
def toggle_music(self):
self.music.toggle()
def exit(self):
self.win.has_exit = True
class ExpWindow(object):
def __init__(self, background_color=dark_gray, clock=mono_clock.get_time):
# lazy load, partially to avoid auto-formatter that wants to
# do imports, *then* dict setting
from pyglet import gl
from pyglet.window import Window
self._background_color = Vector4f(background_color)
self.clock = clock
self.current_time = 0
self.prev_time = 0
# can bump down `samples` if performance is hurting
config = gl.Config(depth_size=0, double_buffer=True,
alpha_size=8, sample_buffers=1,
samples=4, vsync=False,
major_version=3, minor_version=3)
display = pyglet.canvas.get_display()
screen = display.get_screens()[0]
self._win = Window(resizable=False, fullscreen=True,
screen=screen, config=config,
style='borderless', vsync=True)
self._win.event(self.on_key_press)
atexit.register(self._on_close)
self.context = mgl.create_context(require=int('%i%i0' % (config.major_version,
config.minor_version)))
self.context.viewport = (0, 0, self.width, self.height)
self.context.enable(mgl.BLEND)
self.frame_period # do this before we've drawn anything
# in principle, should be disconnected from the window
# but we're saving time & mental energy
self.cam = Camera(projection=height_ortho(self.width, self.height))
def on_key_press(self, symbol, modifiers):
if symbol == pyglet.window.key.ESCAPE:
sys.exit(1)
def _on_close(self):
if self._win.context:
self._win.close()
def flip(self):
self._win.switch_to()
self._win.dispatch_events()
self._win.flip()
self.context.clear(*self._background_color)
current_time = self.clock()
self.prev_time = self.current_time
self.current_time = current_time
return self.current_time
def close(self):
self._win.close()
@property
def dt(self):
return self.current_time - self.prev_time
def set_mouse_visible(self, val):
self._win.set_mouse_visible(val)
@property
def width(self):
return self._win.width
@property
def height(self):
return self._win.height
@property
def background_color(self):
return self._background_color
@background_color.setter
def background_color(self, val):
if len(val) != 4:
raise ValueError('Background color must be RGBA.')
self._background_color.xyzw = val
@property
def frame_period(self):
# get a whole-number version of the frame period
# very coarse and fragile, should get this from the
# the video mode, e.g. glfw.get_video_mode
if not hasattr(self, '_frame_period'):
possible = [60.0, 144.0, 240.0] # TODO: infer from machine...
vals = []
for _ in range(20):
self.flip()
vals.append(self.dt)
# chop off the first few, which are not reflective of the
# "real" FPS
avg = 1/(sum(vals[5:])/float(len(vals[5:])))
dff = [abs(avg - p) for p in possible]
fps = [v for v, d in zip(possible, dff) if d == min(dff)]
if not len(fps):
self._frame_period = 1/60.0 # default
else:
self._frame_period = 1/fps[0]
return self._frame_period
import pyglet
from pyglet.window import mouse
from time import time, sleep
from pyglet.window import Window
from math import pi, radians, cos, sin
screen_width = 640
screen_height = 480
window = Window(width=screen_width, height=screen_height)
window.set_mouse_visible(False)
class Wall:
def __init__(self,
type,
pos_x=0,
pos_y=screen_height / 2,
width=10,
height=100):
self.type = type
self.pos_x = pos_x
self.pos_y = pos_y
self.width = width
self.height = height
def mouse_move(self, x=screen_width - 10, y=screen_height / 2, dx=0, dy=0):
x = x + dx
self.pos_x = x
y = y + dy
self.pos_y = y
import pyglet
from pyglet.window import mouse
from time import time, sleep
from pyglet.window import Window
from math import pi, radians, cos, sin, floor
import math
from map import Map
from enemies import Enemies
from towers import Towers, Tower, AttackTower, DefenceTower
from menu import Menu
from pyglet.window import mouse
screen_width = 1280
screen_height = 960
window = Window(width=screen_width, height=screen_height)
window.set_mouse_visible(True)
# window.set_fullscreen(True)
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()
