def test_motion(self):
w = Window(200, 200)
try:
w.push_handlers(self)
while not w.has_exit:
w.dispatch_events()
finally:
w.close()
self.user_verify('Pass test?', take_screenshot=False)
def test_resize(self):
w = Window(200, 200, resizable=True)
try:
w.push_handlers(self)
while not w.has_exit:
window_util.draw_client_border(w)
w.flip()
w.dispatch_events()
finally:
w.close()
self.user_verify('Pass test?', take_screenshot=False)
class Gameloop(object):
def __init__(self):
self.window = None
def init(self):
self.world = World()
self.world.init()
populate(self.world)
bitmaps = Bitmaps()
bitmaps.load()
self.render = Render(bitmaps)
self.camera = Camera(zoom=10.0)
self.window = Window(fullscreen=False, visible=False)
self.window.set_exclusive_mouse(True)
self.window.on_draw = self.draw
self.window.on_resize = self.render.resize
self.controls = Controls(self.world.bat)
self.window.set_handlers(self.controls)
self.render.init()
clock.schedule(self.update)
self.hud_fps = clock.ClockDisplay()
self.window.set_visible()
def update(self, dt):
# scale dt such that the 'standard' framerate of 60fps gives dt=1.0
dt *= 60.0
# don't attempt to compensate for framerate of less than 30fps. This
# guards against huge explosion when game is paused for any reason
# and then restarted
dt = min(dt, 2)
self.controls.update()
self.world.update()
self.window.invalid = True
def draw(self):
self.window.clear()
self.camera.world_projection(self.window.width, self.window.height)
self.camera.look_at()
self.render.draw(self.world)
self.hud_fps.draw()
return EVENT_HANDLED
def stop(self):
if self.window:
self.window.close()
class Gameloop(object):
def __init__(self):
self.camera = None
self.projection = None
self.render = None
self.window = None
self.world = None
self.fpss = []
def prepare(self, options):
self.window = Window(fullscreen=options.fullscreen, vsync=False, visible=False, resizable=True)
self.window.on_draw = self.draw
self.projection = Projection(self.window.width, self.window.height)
self.window.on_resize = self.projection.resize
self.world = World()
self.camera = Camera()
self.world.add(GameItem(camera=self.camera, position=Origin, move=WobblyOrbit(32, 1, speed=-0.5)))
self.render = Render(self.world)
self.render.init()
pyglet.clock.schedule(self.update)
self.clock_display = pyglet.clock.ClockDisplay()
vs = VertexShader(join("flyinghigh", "shaders", "lighting.vert"))
fs = FragmentShader(join("flyinghigh", "shaders", "lighting.frag"))
shader = ShaderProgram(vs, fs)
shader.use()
def update(self, dt):
# self.fpss.append(1/max(1e-3, dt))
dt = min(dt, 1 / 30)
self.world.update(dt)
self.window.invalid = True
def draw(self):
self.window.clear()
self.projection.set_perspective(45)
self.camera.look_at(Origin)
self.render.draw()
self.projection.set_screen()
self.camera.reset()
self.render.draw_hud(self.clock_display)
return EVENT_HANDLED
def stop(self):
if self.window:
self.window.close()
class PygletApp(object):
def __init__(self):
self.window = Window(visible=False, fullscreen=False)
self.window.on_resize = self.on_resize
self.window.on_draw = self.on_draw
self.window.on_key_press = self.on_key_press
self.files = SvgFiles()
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
gluLookAt(
0.0, -0.0, 1.0, # eye
0.0, -0.0, -1.0, # lookAt
0.0, 1.0, 0.0) # up
def on_draw(self):
glClear(GL_COLOR_BUFFER_BIT)
self.files.draw()
return EVENT_HANDLED
def on_resize(self, width, height):
# scale is distance from screen centre to top or bottom, in world coords
scale = 110
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
aspect = width / height
gluOrtho2D(
-scale * aspect,
+scale * aspect,
-scale,
+scale)
return EVENT_HANDLED
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE:
self.window.close()
return
self.files.next()
def run(self):
self.window.set_visible()
app.run()
class PygletApp(object):
def __init__(self):
self.window = Window(visible=False, fullscreen=False)
self.window.on_resize = self.on_resize
self.window.on_draw = self.on_draw
self.window.on_key_press = self.on_key_press
self.files = SvgFiles()
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
gluLookAt(
0.0, -0.0, 1.0, # eye
0.0, -0.0, -1.0, # lookAt
0.0, 1.0, 0.0) # up
def on_draw(self):
glClear(GL_COLOR_BUFFER_BIT)
self.files.draw()
return EVENT_HANDLED
def on_resize(self, width, height):
# scale is distance from screen centre to top or bottom, in world coords
scale = 110
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
aspect = width / height
gluOrtho2D(
-scale * aspect,
+scale * aspect,
-scale,
+scale)
return EVENT_HANDLED
def on_key_press(self, symbol, modifiers):
if symbol == key.ESCAPE:
self.window.close()
return
self.files.next()
def run(self):
self.window.set_visible()
app.run()
def test_caption(self):
try:
w1 = Window(400, 200, resizable=True)
w2 = Window(400, 200, resizable=True)
count = 1
w1.set_caption('Window caption %d' % count)
w2.set_caption(u'\u00bfHabla espa\u00f1ol?')
last_time = time.time()
while not (w1.has_exit or w2.has_exit):
if time.time() - last_time > 1:
count += 1
w1.set_caption('Window caption %d' % count)
last_time = time.time()
w1.dispatch_events()
w2.dispatch_events()
finally:
w1.close()
w2.close()
self.user_verify('Pass test?', take_screenshot=False)
def test_set_visible(self):
w = Window(200, 200)
try:
w.push_handlers(WindowEventLogger())
w.dispatch_events()
self.user_verify('Is the window visible?', take_screenshot=False)
w.set_visible(False)
w.dispatch_events()
self.user_verify('Is the window no longer visible?',
take_screenshot=False)
w.set_visible(True)
w.dispatch_events()
self.user_verify('Is the window visible again?',
take_screenshot=False)
finally:
w.close()
class ImageViewer:
def __init__(self, display=None, maxwidth=500):
self.window = None
self.isopen = False
self.display = display
def __del__(self):
self.close()
def imshow(self, arr, caption):
if self.window is None:
height, width, _ = arr.shape
self.window = Window(width=width,
height=height,
display=self.display,
vsync=False,
resizable=True)
self.width = width
self.height = height
self.isopen = True
assert len(arr.shape) == 3
height, width, _ = arr.shape
image = pyglet.image.ImageData(width,
height,
'RGB',
arr.tobytes(),
pitch=-3 * width)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
texture = image.get_texture()
texture.width = self.width
texture.height = self.height
self.window.clear()
self.window.switch_to()
self.window.dispatch_events()
texture.blit(0, 0)
self.window.flip()
self.window.set_caption(caption)
def close(self):
if self.isopen:
self.window.close()
self.isopen = False
class NumpyTube:
def __init__(self):
self.window = None
self.isopen = False
def __del__(self):
self.close()
def imshow(self, img, caption=None):
height, width, _ = img.shape
pitch = -3 * width
if self.window is None:
self.window = Window(width=width, height=height, vsync=False)
self.width = width
self.height = height
self.isopen = True
data = img.tobytes()
image = pyglet.image.ImageData(width, height, "RGB", data, pitch=pitch)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
texture = image.get_texture()
texture.width = self.width
texture.height = self.height
self.window.clear()
self.window.switch_to()
self.window.dispatch_events()
texture.blit(0, 0)
self.window.flip()
if caption is not None:
self.window.set_caption(caption)
def close(self):
if self.isopen:
self.window.close()
self.window = None
self.isopen = False
class App(object):
def __init__(self, pmap):
self.world = World(pmap)
self.win = Window(width=pmap['bounds'][2], height=pmap['bounds'][3])
# pyglet.clock.set_fps_limit(10)
# pyglet.clock.set_fps_limit(60)
self.win.push_handlers(self.on_key_press)
self.fullscreen = False
def main_loop(self):
self.world.annealing.kickoff()
while not (self.win.has_exit or self.world.finished):
self.win.dispatch_events()
if (not self.world.finished) and (not self.world.pause):
self.world.update()
if (self.world.showvisuals):
self.world.draw()
pyglet.clock.tick()
self.win.flip()
self.win.close()
def on_key_press(self, symbol, modifiers):
# IDEA more key toggles, make it a dictionary
if symbol == key.D:
self.world.showdebug = not self.world.showdebug
elif symbol == key.F:
self.fullscreen = not self.fullscreen
self.win.set_fullscreen(fullscreen=self.fullscreen)
self.world.draw()
elif symbol == key.G:
self.world.showgrid = not self.world.showgrid
elif symbol == key.S:
self.world.pause = not self.world.pause
elif symbol == key.U:
self.world.showUI = not self.world.showUI
elif symbol == key.V:
self.world.showvisuals = not self.world.showvisuals
glPopMatrix()
camera.hud_mode(win.width, win.height)
clockDisplay.draw()
def update(dt):
for idx, entity in enumerate(entities):
entity.angle += ((entity.x) + abs(entity.y)) / 10000
entity.x += sin(entity.angle) / (1+idx) * 10
entity.y -= cos(entity.angle) / (1+idx) * 10
camera.zoom(1.008)
clock.schedule(update) # triggers on_draw event when done
key_handlers = {
key.ESCAPE: lambda: win.close(),
key.PAGEUP: lambda: camera.zoom(2),
key.PAGEDOWN: lambda: camera.zoom(0.5),
key.LEFT: lambda: camera.pan(camera.scale, -pi/2),
key.RIGHT: lambda: camera.pan(camera.scale, +pi/2),
key.DOWN: lambda: camera.pan(camera.scale, pi),
key.UP: lambda: camera.pan(camera.scale, 0),
key.COMMA: lambda: camera.tilt(-1),
key.PERIOD: lambda: camera.tilt(+1),
}
@win.event
def on_key_press(symbol, modifiers):
handler = key_handlers.get(symbol, lambda: None)
handler()
class MapModelTest(unittest.TestCase):
def setUp(self):
self.w = Window(width=1, height=1, visible=False)
def tearDown(self):
self.w.close()
def test_rect_neighbor(self):
# test rectangular tile map
# +---+---+---+
# | d | e | f |
# +---+---+---+
# | a | b | c |
# +---+---+---+
m = gen_rect_map(rmd, 10, 16)
t = m.get_cell(0, 0)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'd'
assert m.get_neighbor(t, m.LEFT) is None
assert m.get_neighbor(t, m.RIGHT).properties['meta'] == 'b'
t = m.get_neighbor(t, m.UP)
assert (t.x, t.y) == (0, 1) and t.properties['meta'] == 'd'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'a'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.LEFT) is None
assert m.get_neighbor(t, m.RIGHT).properties['meta'] == 'e'
t = m.get_neighbor(t, m.RIGHT)
assert (t.x, t.y) == (1, 1) and t.properties['meta'] == 'e'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'b'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.RIGHT).properties['meta'] == 'f'
assert m.get_neighbor(t, m.LEFT).properties['meta'] == 'd'
t = m.get_neighbor(t, m.RIGHT)
assert (t.x, t.y) == (2, 1) and t.properties['meta'] == 'f'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'c'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.RIGHT) is None
assert m.get_neighbor(t, m.LEFT).properties['meta'] == 'e'
t = m.get_neighbor(t, m.DOWN)
assert (t.x, t.y) == (2, 0) and t.properties['meta'] == 'c'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'f'
assert m.get_neighbor(t, m.RIGHT) is None
assert m.get_neighbor(t, m.LEFT).properties['meta'] == 'b'
def test_rect_coords(self):
# test rectangular tile map
# +---+---+---+
# | d | e | f |
# +---+---+---+
# | a | b | c |
# +---+---+---+
m = gen_rect_map(rmd, 10, 16)
# test tile sides / corners
t = m.get_cell(0, 0)
assert t.top == 16
assert t.bottom == 0
assert t.left == 0
assert t.right == 10
assert t.topleft == (0, 16)
assert t.topright == (10, 16)
assert t.bottomleft == (0, 0)
assert t.bottomright == (10, 0)
assert t.midtop == (5, 16)
assert t.midleft == (0, 8)
assert t.midright == (10, 8)
assert t.midbottom == (5, 0)
def test_rect_pixel(self):
# test rectangular tile map
# +---+---+---+
# | d | e | f |
# +---+---+---+
# | a | b | c |
# +---+---+---+
m = gen_rect_map(rmd, 10, 16)
t = m.get(0, 0)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(9, 15)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(10, 15)
assert (t.x, t.y) == (1, 0) and t.properties['meta'] == 'b'
t = m.get(9, 16)
assert (t.x, t.y) == (0, 1) and t.properties['meta'] == 'd'
t = m.get(10, 16)
assert (t.x, t.y) == (1, 1) and t.properties['meta'] == 'e'
def test_hex_neighbor(self):
# test hexagonal tile map
# tiles = [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h']]
# /d\ /h\
# /b\_/f\_/
# \_/c\_/g\
# /a\_/e\_/
# \_/ \_/
m = gen_hex_map(hmd, 32)
t = m.get_cell(0, 0)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'b'
assert m.get_neighbor(t, m.DOWN_LEFT) is None
assert m.get_neighbor(t, m.DOWN_RIGHT) is None
assert m.get_neighbor(t, m.UP_LEFT) is None
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'c'
t = m.get_neighbor(t, m.UP)
assert (t.x, t.y) == (0, 1) and t.properties['meta'] == 'b'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'a'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.DOWN_LEFT) is None
assert m.get_neighbor(t, m.DOWN_RIGHT).properties['meta'] == 'c'
assert m.get_neighbor(t, m.UP_LEFT) is None
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'd'
t = m.get_neighbor(t, m.DOWN_RIGHT)
assert (t.x, t.y) == (1, 0) and t.properties['meta'] == 'c'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'd'
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'a'
assert m.get_neighbor(t, m.DOWN_RIGHT).properties['meta'] == 'e'
assert m.get_neighbor(t, m.UP_LEFT).properties['meta'] == 'b'
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'f'
t = m.get_neighbor(t, m.UP_RIGHT)
assert (t.x, t.y) == (2, 1) and t.properties['meta'] == 'f'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'e'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'c'
assert m.get_neighbor(t, m.DOWN_RIGHT).properties['meta'] == 'g'
assert m.get_neighbor(t, m.UP_LEFT).properties['meta'] == 'd'
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'h'
t = m.get_neighbor(t, m.DOWN_RIGHT)
assert (t.x, t.y) == (3, 0) and t.properties['meta'] == 'g'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'h'
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'e'
assert m.get_neighbor(t, m.DOWN_RIGHT) is None
assert m.get_neighbor(t, m.UP_LEFT).properties['meta'] == 'f'
assert m.get_neighbor(t, m.UP_RIGHT) is None
t = m.get_neighbor(t, m.UP)
assert (t.x, t.y) == (3, 1) and t.properties['meta'] == 'h'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'g'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'f'
assert m.get_neighbor(t, m.DOWN_RIGHT) is None
assert m.get_neighbor(t, m.UP_LEFT) is None
assert m.get_neighbor(t, m.UP_RIGHT) is None
def test_hex_coords(self):
# test hexagonal tile map
# tiles = [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h']]
# /d\ /h\
# /b\_/f\_/
# \_/c\_/g\
# /a\_/e\_/
# \_/ \_/
m = gen_hex_map(hmd, 32)
# test tile sides / corners
t00 = m.get_cell(0, 0)
assert t00.top == 32
assert t00.bottom == 0
assert t00.left == (0, 16)
assert t00.right == (36, 16)
assert t00.center == (18, 16)
assert t00.topleft == (9, 32)
assert t00.topright == (27, 32)
assert t00.bottomleft == (9, 0)
assert t00.bottomright == (27, 0)
assert t00.midtop == (18, 32)
assert t00.midbottom == (18, 0)
assert t00.midtopleft == (4, 24)
assert t00.midtopright == (31, 24)
assert t00.midbottomleft == (4, 8)
assert t00.midbottomright == (31, 8)
t10 = m.get_cell(1, 0)
assert t10.top == 48
assert t10.bottom == 16
assert t10.left == t00.topright
assert t10.right == (63, 32)
assert t10.center == (45, 32)
assert t10.topleft == (36, 48)
assert t10.topright == (54, 48)
assert t10.bottomleft == t00.right
assert t10.bottomright == (54, 16)
assert t10.midtop == (45, 48)
assert t10.midbottom == (45, 16)
assert t10.midtopleft == (31, 40)
assert t10.midtopright == (58, 40)
assert t10.midbottomleft == t00.midtopright
assert t10.midbottomright == (58, 24)
t = m.get_cell(2, 0)
assert t.top == 32
assert t.bottom == 0
assert t.left == t10.bottomright
assert t.right == (90, 16)
assert t.center == (72, 16)
assert t.topleft == t10.right
assert t.midtopleft == t10.midbottomright
def test_hex_pixel(self):
# test hexagonal tile map
# tiles = [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h']]
# /d\ /h\
# /b\_/f\_/
# \_/c\_/g\
# /a\_/e\_/
# \_/ \_/
m = gen_hex_map(hmd, 32)
t = m.get(0, 0)
assert t is None
t = m.get(0, 16)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(16, 16)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(35, 16)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(36, 16)
assert (t.x, t.y) == (1, 0) and t.properties['meta'] == 'c'
def test_hex_dimensions(self):
m = gen_hex_map([[{'a': 'a'}]], 32)
assert m.pxw, m.pxh == (36, 32)
m = gen_hex_map([[{'a': 'a'}] * 2], 32)
assert m.pxw, m.pxh == (36, 64)
m = gen_hex_map([[{'a': 'a'}]] * 2, 32)
assert m.pxw, m.pxh == (63, 48)
unittest.main()
class Camera_test(MyTestCase):
def setUp(self):
self.window = Window(
width=200, height=100, visible=False, caption="Camera_test setup")
self.window.dispatch_events()
glClearColor(0, 0, 0, 1)
self.window.clear()
self.world = World()
self.camera = Camera((0, 0), 1)
def tearDown(self):
self.window.close()
def test_constructor(self):
camera = Camera((1, 2), 3, 4)
self.assertEquals(camera.x, 1, "should init x")
self.assertEquals(camera.y, 2, "should init y")
self.assertEquals(camera.scale, 3, "should init scale")
self.assertEquals(camera.angle, 4, "should init angle")
def test_constructor_defaults_angle(self):
camera = Camera((10, 20), 30)
self.assertEquals(camera.angle, 0.0, "should init angle")
def _draw_rect(self, backColor, polyColor, left, bottom, right, top):
glClearColor(
backColor[0]/255,
backColor[1]/255,
backColor[2]/255,
1.0)
self.window.clear()
verts = [
(left, bottom),
(right, bottom),
(right, top),
(left, top),
]
glColor3ub(*polyColor)
glBegin(GL_TRIANGLE_FAN)
for vert in verts:
glVertex2f(*vert)
glEnd()
def test_world_projection_default(self):
rect = (-0.2, -0.4, +0.6, +0.8)
expectedRect = (90, 10, 129, 69)
self.assert_world_projection(rect, expectedRect)
def test_defect_pyglet_get_color_buffer_for_resized_windows(self):
self.window.set_size(111, 222)
self.window.dispatch_events()
mgr = get_buffer_manager()
col_buf = mgr.get_color_buffer()
col_buf_size = col_buf.width, col_buf.height
self.assertEquals(col_buf_size, (111, 222), "pyglet bug regression")
def test_world_projection_strange_aspect(self):
# create a new window, since
# resizing the existing window doesn't work for some reason
# even if we dispatch events. Default handlers?
self.window.close()
self.window = Window(
width=100, height=200, visible=False,
caption="world.test_projection_strange_aspect")
self.window.dispatch_events()
rect = (-0.2, -0.4, +0.6, +0.8)
expectedRect = (40, 60, 79, 119)
self.assert_world_projection(rect, expectedRect)
def test_world_projection_offset(self):
self.camera.x, self.camera.y = (+0.5, +0.3)
rect = (-0.2, -0.4, +0.6, +0.8)
expectedRect = (65, 25, 104, 84)
self.assert_world_projection(rect, expectedRect)
def test_world_projection_scale(self):
self.camera.scale = 10
rect = (-1, -2, +3, +4)
expectedRect = (95, 30, 114, 59)
self.assert_world_projection(rect, expectedRect)
def test_world_projection_angle(self):
self.camera.angle = pi/2
rect = (-0.2, -0.4, +0.6, +0.8)
expectedRect = (60, 20, 119, 59)
self.assert_world_projection(rect, expectedRect)
def test_world_projection_complicated(self):
self.camera.angle = -pi/2
self.camera.scale = 10
self.camera.x, self.camera.y = (5, 6)
rect = (-1, -2, +3, +4)
expectedRect = (60, 20, 89, 39)
self.assert_world_projection(rect, expectedRect)
class ImageViewer(object):
def __init__(self, width, height, display=None):
from pyglet.window import Window
self.sheet = SpriteSheet()
self.display = display
self.window = Window(width=width * self.sheet.BLOCK_WIDTH,
height=height * self.sheet.BLOCK_WIDTH,
display=self.display)
self.isopen = True
self.init_blend()
def init_blend(self):
from pyglet.gl import (GL_BLEND, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA,
glBlendFunc, glEnable)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
def render_state(self, state, x_offset=0, flip=True):
import pyglet
darken = pyglet.image.SolidColorImagePattern(color=(0, 0, 0, 128))
if flip:
self.begin_flip()
for i, entity in enumerate(state.entities):
if entity is None:
continue
y, x = divmod(i, state.width)
neighbours = [None] * 4
neighbours[1] = state[x, y - 1]
neighbours[0] = state[x, y + 1]
neighbours[3] = state[x - 1, y]
neighbours[2] = state[x + 1, y]
if state.tsu_rules:
if y == 0:
neighbours = [None] * 4
elif y == 1:
neighbours[1] = None
sprite = self.sheet.get_sprite(entity, neighbours)
sprite.blit(
(x + x_offset) * self.sheet.BLOCK_WIDTH,
(state.height - 1 - y) * self.sheet.BLOCK_WIDTH,
)
if state.tsu_rules and y == 0:
mask = darken.create_image(self.sheet.BLOCK_WIDTH + 1,
self.sheet.BLOCK_WIDTH)
mask.blit(
(x + x_offset) * self.sheet.BLOCK_WIDTH,
(state.height - 1 - y) * self.sheet.BLOCK_WIDTH,
)
for i, deal in enumerate(state.deals):
for j, entity in enumerate(deal):
neighbours = [None] * 4
# Deals are usually not rendered "sticky"
# neighbours[2 + j] = deal[1 - j]
sprite = self.sheet.get_sprite(entity, neighbours)
sprite.blit(
(state.width + 2 + j + x_offset) * self.sheet.BLOCK_WIDTH,
(state.height - 1 - 2 * i) * self.sheet.BLOCK_WIDTH,
)
if flip:
self.end_flip()
def begin_flip(self):
self.window.clear()
self.window.switch_to()
self.window.dispatch_events()
def end_flip(self):
self.window.flip()
def save_screenshot(self, filename):
from pyglet.image import get_buffer_manager
get_buffer_manager().get_color_buffer().save(filename)
def close(self):
if self.isopen:
self.window.close()
self.isopen = False
def __del__(self):
self.close()
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
numsprites = int(sys.argv[1])
for i in range(numsprites):
x = random.randint(0, w.width-img.width)
y = random.randint(0, w.height-img.height)
s = BouncySprite(x, y, img.width, img.height, img)
s.dx = random.randint(-10, 10)
s.dy = random.randint(-10, 10)
sprites.append(s)
view = FlatView.from_window(w, sprites=sprites)
view.fx, view.fy = w.width/2, w.height/2
t = 0
numframes = 0
while 1:
if w.has_exit:
print 'FPS:', clock.get_fps()
print 'us per sprite:', float(t) / (numsprites * numframes) * 1000000
break
t += clock.tick()
w.dispatch_events()
for s in sprites: s.update()
view.clear()
view.draw()
w.flip()
numframes += 1
w.close()
class ImageViewer(object):
"""A simple class for viewing images using pyglet."""
def __init__(self,
caption,
height,
width,
monitor_keyboard=False,
relevant_keys=None):
"""
Initialize a new image viewer.
Args:
caption (str): the caption/title for the window
height (int): the height of the window
width (int): the width of the window
monitor_keyboard: whether to monitor events from the keyboard
relevant_keys: the relevant keys to monitor events from
Returns:
None
"""
self.caption = caption
self.height = height
self.width = width
self.monitor_keyboard = monitor_keyboard
self.relevant_keys = relevant_keys
self._window = None
self._pressed_keys = []
self._is_escape_pressed = False
@property
def is_open(self):
"""Return a boolean determining if this window is open."""
return self._window is not None
@property
def is_escape_pressed(self):
"""Return True if the escape key is pressed."""
return self._is_escape_pressed
@property
def pressed_keys(self):
"""Return a sorted list of the pressed keys."""
return tuple(sorted(self._pressed_keys))
def _handle_key_event(self, symbol, is_press):
"""
Handle a key event.
Args:
symbol: the symbol in the event
is_press: whether the event is a press or release
Returns:
None
"""
# remap the key to the expected domain
symbol = KEY_MAP.get(symbol, symbol)
# check if the symbol is the escape key
if symbol == key.ESCAPE:
self._is_escape_pressed = is_press
return
# make sure the symbol is relevant
if self.relevant_keys is not None and symbol not in self.relevant_keys:
return
# handle the press / release by appending / removing the key to pressed
if is_press:
self._pressed_keys.append(symbol)
else:
self._pressed_keys.remove(symbol)
def on_key_press(self, symbol, modifiers):
"""Respond to a key press on the keyboard."""
self._handle_key_event(symbol, True)
def on_key_release(self, symbol, modifiers):
"""Respond to a key release on the keyboard."""
self._handle_key_event(symbol, False)
def open(self):
"""Open the window."""
# create a window for this image viewer instance
self._window = Window(
caption=self.caption,
height=self.height,
width=self.width,
vsync=False,
resizable=True,
)
# add keyboard event monitors if enabled
if self.monitor_keyboard:
self._window.event(self.on_key_press)
self._window.event(self.on_key_release)
self._window.set_exclusive_keyboard()
def close(self):
"""Close the window."""
if self.is_open:
self._window.close()
self._window = None
def show(self, frame):
"""
Show an array of pixels on the window.
Args:
frame (numpy.ndarray): the frame to show on the window
Returns:
None
"""
# check that the frame has the correct dimensions
if len(frame.shape) != 3:
raise ValueError('frame should have shape with only 3 dimensions')
# open the window if it isn't open already
if not self.is_open:
self.open()
# prepare the window for the next frame
self._window.clear()
self._window.switch_to()
self._window.dispatch_events()
# create an image data object
image = ImageData(frame.shape[1],
frame.shape[0],
'RGB',
frame.tobytes(),
pitch=frame.shape[1] * -3)
# send the image to the window
image.blit(0, 0, width=self._window.width, height=self._window.height)
self._window.flip()
camera.hud_mode(win.width, win.height)
clockDisplay.draw()
def update(dt):
for idx, entity in enumerate(entities):
entity.angle += ((entity.x) + abs(entity.y)) / 10000
entity.x += sin(entity.angle) / (1 + idx) * 10
entity.y -= cos(entity.angle) / (1 + idx) * 10
camera.zoom(1.008)
clock.schedule(update) # triggers on_draw event when done
key_handlers = {
key.ESCAPE: lambda: win.close(),
key.PAGEUP: lambda: camera.zoom(2),
key.PAGEDOWN: lambda: camera.zoom(0.5),
key.LEFT: lambda: camera.pan(camera.scale, -pi / 2),
key.RIGHT: lambda: camera.pan(camera.scale, +pi / 2),
key.DOWN: lambda: camera.pan(camera.scale, pi),
key.UP: lambda: camera.pan(camera.scale, 0),
key.COMMA: lambda: camera.tilt(-1),
key.PERIOD: lambda: camera.tilt(+1),
}
@win.event
def on_key_press(symbol, modifiers):
handler = key_handlers.get(symbol, lambda: None)
handler()
sprites = []
numsprites = int(sys.argv[1])
for i in range(numsprites):
x = random.randint(0, w.width - img.width)
y = random.randint(0, w.height - img.height)
s = BouncySprite(x, y, img.width, img.height, img)
s.dx = random.randint(-10, 10)
s.dy = random.randint(-10, 10)
sprites.append(s)
view = FlatView.from_window(w, sprites=sprites)
view.fx, view.fy = w.width / 2, w.height / 2
t = 0
numframes = 0
while 1:
if w.has_exit:
print 'FPS:', clock.get_fps()
print 'us per sprite:', float(t) / (numsprites * numframes) * 1000000
break
t += clock.tick()
w.dispatch_events()
for s in sprites:
s.update()
view.clear()
view.draw()
w.flip()
numframes += 1
w.close()
class SpriteModelTest(unittest.TestCase):
def setUp(self):
self.w = Window(width=1, height=1, visible=False)
self.s = Sprite(
10, 10, 10, 10,
Image2d.from_image(
SolidColorImagePattern((0, 0, 0, 0)).create_image(1, 1)))
assert (self.s.x, self.s.y) == (10, 10)
def tearDown(self):
self.w.close()
def test_top(self):
assert self.s.top == 20
self.s.top = 10
assert (self.s.x, self.s.y) == (10, 0)
def test_bottom(self):
assert self.s.bottom == 10
self.s.bottom = 0
assert (self.s.x, self.s.y) == (10, 0)
def test_right(self):
assert self.s.right == 20
self.s.right = 10
assert (self.s.x, self.s.y) == (0, 10)
def test_left(self):
assert self.s.left == 10
self.s.left = 0
assert (self.s.x, self.s.y) == (0, 10)
def test_center(self):
assert self.s.center == (15, 15)
self.s.center = (5, 5)
assert (self.s.x, self.s.y) == (0, 0)
def test_midtop(self):
assert self.s.midtop == (15, 20)
self.s.midtop = (5, 5)
assert (self.s.x, self.s.y) == (0, -5)
def test_midbottom(self):
assert self.s.midbottom == (15, 10)
self.s.midbottom = (5, 5)
assert (self.s.x, self.s.y) == (0, 5)
def test_midleft(self):
assert self.s.midleft == (10, 15)
self.s.midleft = (5, 5)
assert (self.s.x, self.s.y) == (5, 0)
def test_midright(self):
assert self.s.midright == (20, 15)
self.s.midright = (5, 5)
assert (self.s.x, self.s.y) == (-5, 0)
def test_topleft(self):
assert self.s.topleft == (10, 20)
self.s.topleft = (5, 5)
assert (self.s.x, self.s.y) == (5, -5)
def test_topright(self):
assert self.s.topright == (20, 20)
self.s.topright = (5, 5)
assert (self.s.x, self.s.y) == (-5, -5)
def test_bottomright(self):
assert self.s.bottomright == (20, 10)
self.s.bottomright = (5, 5)
assert (self.s.x, self.s.y) == (-5, 5)
def test_bottomleft(self):
assert self.s.bottomleft == (10, 10)
self.s.bottomleft = (5, 5)
assert (self.s.x, self.s.y) == (5, 5)
unittest.main()
class Gameloop(object):
def __init__(self, options):
self.options = options
self.window = None
self.fpss = []
self.time = 0.0
self.level = None
def prepare(self, options):
self.window = Window(
fullscreen=options.fullscreen,
vsync=options.vsync,
visible=False,
resizable=True)
self.window.on_draw = self.draw_window
self.world = World()
self.player = Player(self.world)
self.camera = GameItem(
position=origin,
update=CameraMan(self.player, (3, 2, 0)),
)
self.level_loader = Level(self)
success = self.start_level(1)
if not success:
logging.error("ERROR, can't load level 1")
sys.exit(1)
self.update(1/60)
self.window.push_handlers(KeyHandler(self.player))
self.render = Render(self.world, self.window, self.camera)
self.render.init()
self.music = Music()
self.music.load()
self.music.play()
def run(self):
pyglet.clock.schedule(self.update)
self.window.set_visible()
self.window.invalid = False
pyglet.app.run()
def update(self, dt):
if self.options.print_fps:
self.fpss.append(1/max(1e-6, dt))
dt = min(dt, 1 / 30)
self.time += dt
for item in self.world:
if hasattr(item, 'update'):
item.update(item, dt, self.time)
if self.player_at_exit():
self.world.remove(self.player)
pyglet.clock.schedule_once(
lambda *_: self.start_level(self.level + 1),
1.0
)
self.window.invalid = True
def start_level(self, n):
success = self.level_loader.load(self.world, n)
if not success:
logging.info('No level %d' % (n,))
self.stop()
return False
self.level = n
pyglet.clock.schedule_once(
lambda *_: self.world.add(self.player),
2.0,
)
return True
def player_at_exit(self):
items = self.world.collision.get_items(self.player.position)
if any(hasattr(item, 'exit') for item in items):
dist2_to_exit = dist2_from_int_ords(self.player.position)
if dist2_to_exit < EPSILON2:
return True
return False
def draw_window(self):
self.window.clear()
self.render.draw_world()
if self.options.display_fps:
self.render.draw_hud()
self.window.invalid = False
return EVENT_HANDLED
def stop(self):
if self.window:
self.window.close()
if self.options.print_fps:
print ' '.join("%6.1f" % (dt, ) for dt in self.fpss)
class Gameloop(object):
instance = None
def __init__(self):
Gameloop.instance = self
self.window = None
self.camera = None
self.world = None
self.renderer = None
self.paused = False
self.fps_display = None
Keyboard.handlers.update({
key.PAGEUP: lambda: self.camera.zoom(2.0),
key.PAGEDOWN: lambda: self.camera.zoom(0.5),
key.ESCAPE: self.quit_game,
key.PAUSE: self.toggle_pause,
key.F12: lambda: save_screenshot(self.window),
})
def init(self, name, version):
clock.set_fps_limit(FPS_LIMIT)
self.fps_display = clock.ClockDisplay()
self.camera = Camera((0, 0), 800)
self.renderer = Renderer(self.camera)
caption = '%s v%s' % (name, version)
self.window = Window(
caption=caption, fullscreen=True, visible=False)
self.window.on_key_press = on_key_press
self.window.push_handlers(Keyboard.keystate)
graphics = load_graphics()
self.world = World()
builder = LevelBuilder()
seed(1)
builder.build(self.world, 75, graphics)
self.world.player = Player()
self.world.player.add_to_space(self.world.space, (0, 200), 0)
self.world.chunks.update(self.world.player.chunks)
def dispose(self):
if self.window:
self.window.close()
def run(self):
try:
self.window.set_visible()
while not self.window.has_exit:
self.window.dispatch_events()
clock.tick()
if self.world and not self.paused:
self.world.tick(1/FPS_LIMIT)
if self.world and hasattr(self.world, 'player'):
player_position = self.world.player.chunks[0].body.position
self.camera.x, self.camera.y = player_position
self.camera.angle = atan2(
player_position.x,
player_position.y)
self.camera.update()
if self.renderer:
aspect = (
self.window.width / self.window.height)
self.renderer.draw(self.world, aspect)
self.camera.hud_projection(
(self.window.width, self.window.height))
self.fps_display.draw()
self.window.flip()
finally:
self.dispose()
def toggle_pause(self):
self.paused = not self.paused
def quit_game(self):
self.window.has_exit = True
class Game(object):
INITIAL_UPDATE_INTERVAL = UPDATE_INTERVAL
def __init__(self):
impl.funcs.load_resources()
self.gameInfo = GameInfo()
self.win = Window(FIELD_WIDTH, FIELD_HEIGHT)
self.win.set_caption("snake")
impl.funcs.setup_background_color()
impl.funcs.setup_opengl_blend_func()
self.gameField = GameField(self.gameInfo, self.win)
self.menu = Menu(FIELD_WIDTH//2, FIELD_HEIGHT//2, self.game_start_callback, self.game_exit_callback, self.win)
self._overlay = None
self._update_interval = Game.INITIAL_UPDATE_INTERVAL
@self.gameField.event
def on_restart_snake():
unschedule(func=self.update)
self._setup_overlay("restart")
schedule_once(func=self.run_snake, delay=DELAY_FOR_NEW_RUN)
@self.gameField.event
def on_rerun_menu():
unschedule(func=self.update)
#reset current handler
self.win.pop_handlers()
#and setup update handler
self.win.push_handlers(self.menu)
self.menu.start_bgrn_animation()
@self.gameField.event
def on_game_over():
unschedule(func=self.update)
self._setup_overlay('game over...')
schedule_once(func=self.game_exit_callback, delay=DELAY_FOR_EXIT)
@self.gameField.event
def on_score_up():
if self._update_interval > MAX_UPDATE_SPEED_INTERVAL:
self._update_interval -= UPDATE_INTERVAL_SPEED_DX
unschedule(func=self.update)
schedule_interval(func=self.update,interval=self._update_interval)
def _setup_overlay(self, text):
self._overlay = BouncingLabel(FIELD_WIDTH//2,FIELD_HEIGHT//2,text,DEFAULT_OVERLAY_COLOR)
self.win.pop_handlers()
def on_draw():
self.win.clear()
self._overlay.draw()
self.win.push_handlers(on_draw)
schedule_interval(func=self._overlay.update, interval=OVERLAY_UPDATE_INTERVAL)
def game_start_callback(self):
self._setup_overlay("start")
schedule_once(func=self.run_snake, delay=DELAY_FOR_NEW_RUN)
def game_exit_callback(self, *args):
if self._overlay:
unschedule(self._overlay.update)
self._overlay = None
self.win.pop_handlers()
self.win.close()
def start(self):
self.win.push_handlers(self.menu)
pyglet.app.run()
def update(self, dt):
if not self.gameInfo.pause:
self.gameField.update(dt)
def run_snake(self, *args):
if self._overlay:
unschedule(self._overlay.update)
self._overlay = None
#reset current handlers
self.win.pop_handlers()
self.gameInfo.pause = False
self.gameField.reset()
#setup new handlers
self.win.push_handlers(self.gameField)
#and setup update handler
self._update_interval = Game.INITIAL_UPDATE_INTERVAL
schedule_interval(func=self.update,interval=self._update_interval)
class ImageViewer(object):
"""A simple class for viewing images using pyglet."""
def __init__(self, caption, height, width):
"""
Initialize a new image viewer.
Args:
caption (str): the caption/title for the window
height (int): the height of the window
width (int): the width of the window
Returns:
None
"""
self.caption = caption
self.height = height
self.width = width
self._window = None
def __repr__(self):
"""Return an executable string representing this object."""
template = '{}(caption={}, height={}, width={})'
return template.format(self.caption, self.height, self.width)
def __del__(self):
"""Close any open windows and delete this object."""
self.close()
@property
def is_open(self):
"""Return a boolean determining if this window is open."""
return self._window is not None
def open(self):
"""Open the window."""
self._window = Window(
caption=self.caption,
height=self.height,
width=self.width,
vsync=False,
resizable=True,
)
def show(self, frame):
"""
Show an array of pixels on the window.
Args:
frame (numpy.ndarray): the frame to show on the window
Returns:
None
"""
# check that the frame has the correct dimensions
if len(frame.shape) != 3:
raise ValueError('frame should have shape with only 3 dimensions')
# open the window if it isn't open already
if not self.is_open:
self.open()
# prepare the window for the next frame
self._window.clear()
self._window.switch_to()
self._window.dispatch_events()
# create an image data object
image = ImageData(frame.shape[1],
frame.shape[0],
'RGB',
frame.tobytes(),
pitch=frame.shape[1] * -3)
# send the image to the window
image.blit(0, 0, width=self._window.width, height=self._window.height)
self._window.flip()
def close(self):
"""Close the window."""
if self.is_open:
self._window.close()
self._window = None
class MapModelTest(unittest.TestCase):
def setUp(self):
self.w = Window(width=1, height=1, visible=False)
def tearDown(self):
self.w.close()
def test_rect_neighbor(self):
# test rectangular tile map
# +---+---+---+
# | d | e | f |
# +---+---+---+
# | a | b | c |
# +---+---+---+
m = gen_rect_map(rmd, 10, 16)
t = m.get_cell(0,0)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'd'
assert m.get_neighbor(t, m.LEFT) is None
assert m.get_neighbor(t, m.RIGHT).properties['meta'] == 'b'
t = m.get_neighbor(t, m.UP)
assert (t.x, t.y) == (0, 1) and t.properties['meta'] == 'd'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'a'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.LEFT) is None
assert m.get_neighbor(t, m.RIGHT).properties['meta'] == 'e'
t = m.get_neighbor(t, m.RIGHT)
assert (t.x, t.y) == (1, 1) and t.properties['meta'] == 'e'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'b'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.RIGHT).properties['meta'] == 'f'
assert m.get_neighbor(t, m.LEFT).properties['meta'] == 'd'
t = m.get_neighbor(t, m.RIGHT)
assert (t.x, t.y) == (2, 1) and t.properties['meta'] == 'f'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'c'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.RIGHT) is None
assert m.get_neighbor(t, m.LEFT).properties['meta'] == 'e'
t = m.get_neighbor(t, m.DOWN)
assert (t.x, t.y) == (2, 0) and t.properties['meta'] == 'c'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'f'
assert m.get_neighbor(t, m.RIGHT) is None
assert m.get_neighbor(t, m.LEFT).properties['meta'] == 'b'
def test_rect_coords(self):
# test rectangular tile map
# +---+---+---+
# | d | e | f |
# +---+---+---+
# | a | b | c |
# +---+---+---+
m = gen_rect_map(rmd, 10, 16)
# test tile sides / corners
t = m.get_cell(0,0)
assert t.top == 16
assert t.bottom == 0
assert t.left == 0
assert t.right == 10
assert t.topleft == (0, 16)
assert t.topright == (10, 16)
assert t.bottomleft == (0, 0)
assert t.bottomright == (10, 0)
assert t.midtop == (5, 16)
assert t.midleft == (0, 8)
assert t.midright == (10, 8)
assert t.midbottom == (5, 0)
def test_rect_pixel(self):
# test rectangular tile map
# +---+---+---+
# | d | e | f |
# +---+---+---+
# | a | b | c |
# +---+---+---+
m = gen_rect_map(rmd, 10, 16)
t = m.get(0,0)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(9,15)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(10,15)
assert (t.x, t.y) == (1, 0) and t.properties['meta'] == 'b'
t = m.get(9,16)
assert (t.x, t.y) == (0, 1) and t.properties['meta'] == 'd'
t = m.get(10,16)
assert (t.x, t.y) == (1, 1) and t.properties['meta'] == 'e'
def test_hex_neighbor(self):
# test hexagonal tile map
# tiles = [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h']]
# /d\ /h\
# /b\_/f\_/
# \_/c\_/g\
# /a\_/e\_/
# \_/ \_/
m = gen_hex_map(hmd, 32)
t = m.get_cell(0,0)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'b'
assert m.get_neighbor(t, m.DOWN_LEFT) is None
assert m.get_neighbor(t, m.DOWN_RIGHT) is None
assert m.get_neighbor(t, m.UP_LEFT) is None
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'c'
t = m.get_neighbor(t, m.UP)
assert (t.x, t.y) == (0, 1) and t.properties['meta'] == 'b'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'a'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.DOWN_LEFT) is None
assert m.get_neighbor(t, m.DOWN_RIGHT).properties['meta'] == 'c'
assert m.get_neighbor(t, m.UP_LEFT) is None
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'd'
t = m.get_neighbor(t, m.DOWN_RIGHT)
assert (t.x, t.y) == (1, 0) and t.properties['meta'] == 'c'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'd'
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'a'
assert m.get_neighbor(t, m.DOWN_RIGHT).properties['meta'] == 'e'
assert m.get_neighbor(t, m.UP_LEFT).properties['meta'] == 'b'
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'f'
t = m.get_neighbor(t, m.UP_RIGHT)
assert (t.x, t.y) == (2, 1) and t.properties['meta'] == 'f'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'e'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'c'
assert m.get_neighbor(t, m.DOWN_RIGHT).properties['meta'] == 'g'
assert m.get_neighbor(t, m.UP_LEFT).properties['meta'] == 'd'
assert m.get_neighbor(t, m.UP_RIGHT).properties['meta'] == 'h'
t = m.get_neighbor(t, m.DOWN_RIGHT)
assert (t.x, t.y) == (3, 0) and t.properties['meta'] == 'g'
assert m.get_neighbor(t, m.DOWN) is None
assert m.get_neighbor(t, m.UP).properties['meta'] == 'h'
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'e'
assert m.get_neighbor(t, m.DOWN_RIGHT) is None
assert m.get_neighbor(t, m.UP_LEFT).properties['meta'] == 'f'
assert m.get_neighbor(t, m.UP_RIGHT) is None
t = m.get_neighbor(t, m.UP)
assert (t.x, t.y) == (3, 1) and t.properties['meta'] == 'h'
assert m.get_neighbor(t, m.DOWN).properties['meta'] == 'g'
assert m.get_neighbor(t, m.UP) is None
assert m.get_neighbor(t, m.DOWN_LEFT).properties['meta'] == 'f'
assert m.get_neighbor(t, m.DOWN_RIGHT) is None
assert m.get_neighbor(t, m.UP_LEFT) is None
assert m.get_neighbor(t, m.UP_RIGHT) is None
def test_hex_coords(self):
# test hexagonal tile map
# tiles = [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h']]
# /d\ /h\
# /b\_/f\_/
# \_/c\_/g\
# /a\_/e\_/
# \_/ \_/
m = gen_hex_map(hmd, 32)
# test tile sides / corners
t00 = m.get_cell(0, 0)
assert t00.top == 32
assert t00.bottom == 0
assert t00.left == (0, 16)
assert t00.right == (36, 16)
assert t00.center == (18, 16)
assert t00.topleft == (9, 32)
assert t00.topright == (27, 32)
assert t00.bottomleft == (9, 0)
assert t00.bottomright == (27, 0)
assert t00.midtop == (18, 32)
assert t00.midbottom == (18, 0)
assert t00.midtopleft == (4, 24)
assert t00.midtopright == (31, 24)
assert t00.midbottomleft == (4, 8)
assert t00.midbottomright == (31, 8)
t10 = m.get_cell(1, 0)
assert t10.top == 48
assert t10.bottom == 16
assert t10.left == t00.topright
assert t10.right == (63, 32)
assert t10.center == (45, 32)
assert t10.topleft == (36, 48)
assert t10.topright == (54, 48)
assert t10.bottomleft == t00.right
assert t10.bottomright == (54, 16)
assert t10.midtop == (45, 48)
assert t10.midbottom == (45, 16)
assert t10.midtopleft == (31, 40)
assert t10.midtopright == (58, 40)
assert t10.midbottomleft == t00.midtopright
assert t10.midbottomright == (58, 24)
t = m.get_cell(2, 0)
assert t.top == 32
assert t.bottom == 0
assert t.left == t10.bottomright
assert t.right == (90, 16)
assert t.center == (72, 16)
assert t.topleft == t10.right
assert t.midtopleft == t10.midbottomright
def test_hex_pixel(self):
# test hexagonal tile map
# tiles = [['a', 'b'], ['c', 'd'], ['e', 'f'], ['g', 'h']]
# /d\ /h\
# /b\_/f\_/
# \_/c\_/g\
# /a\_/e\_/
# \_/ \_/
m = gen_hex_map(hmd, 32)
t = m.get(0,0)
assert t is None
t = m.get(0,16)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(16,16)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(35,16)
assert (t.x, t.y) == (0, 0) and t.properties['meta'] == 'a'
t = m.get(36,16)
assert (t.x, t.y) == (1, 0) and t.properties['meta'] == 'c'
def test_hex_dimensions(self):
m = gen_hex_map([[{'a':'a'}]], 32)
assert m.pxw, m.pxh == (36, 32)
m = gen_hex_map([[{'a':'a'}]*2], 32)
assert m.pxw, m.pxh == (36, 64)
m = gen_hex_map([[{'a':'a'}]]*2, 32)
assert m.pxw, m.pxh == (63, 48)
class SpriteModelTest(unittest.TestCase):
def setUp(self):
self.w = Window(width=1, height=1, visible=False)
self.s = Sprite(10, 10, 10, 10,
Image2d.from_image(SolidColorImagePattern((0, 0, 0,
0)).create_image(
1, 1)))
assert (self.s.x, self.s.y) == (10, 10)
def tearDown(self):
self.w.close()
def test_top(self):
assert self.s.top == 20
self.s.top = 10
assert (self.s.x, self.s.y) == (10, 0)
def test_bottom(self):
assert self.s.bottom == 10
self.s.bottom = 0
assert (self.s.x, self.s.y) == (10, 0)
def test_right(self):
assert self.s.right == 20
self.s.right = 10
assert (self.s.x, self.s.y) == (0, 10)
def test_left(self):
assert self.s.left == 10
self.s.left = 0
assert (self.s.x, self.s.y) == (0, 10)
def test_center(self):
assert self.s.center == (15, 15)
self.s.center = (5, 5)
assert (self.s.x, self.s.y) == (0, 0)
def test_midtop(self):
assert self.s.midtop == (15, 20)
self.s.midtop = (5, 5)
assert (self.s.x, self.s.y) == (0, -5)
def test_midbottom(self):
assert self.s.midbottom == (15, 10)
self.s.midbottom = (5, 5)
assert (self.s.x, self.s.y) == (0, 5)
def test_midleft(self):
assert self.s.midleft == (10, 15)
self.s.midleft = (5, 5)
assert (self.s.x, self.s.y) == (5, 0)
def test_midright(self):
assert self.s.midright == (20, 15)
self.s.midright = (5, 5)
assert (self.s.x, self.s.y) == (-5, 0)
def test_topleft(self):
assert self.s.topleft == (10, 20)
self.s.topleft = (5, 5)
assert (self.s.x, self.s.y) == (5, -5)
def test_topright(self):
assert self.s.topright == (20, 20)
self.s.topright = (5, 5)
assert (self.s.x, self.s.y) == (-5, -5)
def test_bottomright(self):
assert self.s.bottomright == (20, 10)
self.s.bottomright = (5, 5)
assert (self.s.x, self.s.y) == (-5, 5)
def test_bottomleft(self):
assert self.s.bottomleft == (10, 10)
self.s.bottomleft = (5, 5)
assert (self.s.x, self.s.y) == (5, 5)
unittest.main()
class Gameloop(object):
def __init__(self):
self.camera = None
self.projection = None
self.render = None
self.window = None
self.world = None
self.fpss = []
def prepare(self, options):
self.window = Window(
fullscreen=options.fullscreen,
vsync=False,
visible=False,
resizable=True)
self.window.on_draw = self.draw
self.projection = Projection(self.window.width, self.window.height)
self.window.on_resize = self.projection.resize
self.world = World()
self.camera = Camera()
self.world.add( GameItem(
camera=self.camera,
position=Origin,
move=WobblyOrbit(32, 1, speed=-0.5),
) )
self.render = Render(self.world)
self.render.init()
pyglet.clock.schedule(self.update)
self.clock_display = pyglet.clock.ClockDisplay()
vs = VertexShader(join('flyinghigh', 'shaders', 'lighting.vert'))
fs = FragmentShader(join('flyinghigh', 'shaders', 'lighting.frag'))
shader = ShaderProgram(vs, fs)
shader.use()
def update(self, dt):
# self.fpss.append(1/max(1e-3, dt))
dt = min(dt, 1 / 30)
self.world.update(dt)
self.window.invalid = True
def draw(self):
self.window.clear()
self.projection.set_perspective(45)
self.camera.look_at(Origin)
self.render.draw()
self.projection.set_screen()
self.camera.reset()
self.render.draw_hud(self.clock_display)
return EVENT_HANDLED
def stop(self):
if self.window:
self.window.close()
