def test_delay(self):
for wait in range(5, 200, 5):
start = time.time() * 1000
timer.delay(wait)
end = time.time() * 1000
sum = (end - start)
self.assertTrue(abs(wait - sum) <= 3,
"%f is not <= 3 for %f and %f" % (abs(wait - sum), wait, sum))
def run():
video.init()
window = video.Window("The Pong Game", size=(800, 600))
window.show()
factory = video.SpriteFactory(video.SOFTWARE)
# For hardware acceleration, comment out the above line and uncomment the
# next two lines
#
# renderer = video.RenderContext(window)
# factory = video.SpriteFactory(video.TEXTURE, renderer=renderer)
#
# Create the paddles - we want white ones. To keep it easy enough for us,
# we create a set of surfaces that can be used for Texture- and
# Software-based sprites.
sp_paddle1 = factory.from_color(WHITE, size=(20, 100))
sp_paddle2 = factory.from_color(WHITE, size=(20, 100))
sp_ball = factory.from_color(WHITE, size=(20, 20))
world = World()
movement = MovementSystem(0, 0, 800, 600)
collision = CollisionSystem(0, 0, 800, 600)
aicontroller = TrackingAIController(0, 600)
if factory.sprite_type == video.SOFTWARE:
spriterenderer = SoftwareRenderer(window)
else:
spriterenderer = TextureRenderer(renderer)
world.add_system(aicontroller)
world.add_system(movement)
world.add_system(collision)
world.add_system(spriterenderer)
player1 = Player(world, sp_paddle1, 0, 250)
player2 = Player(world, sp_paddle2, 780, 250, True)
ball = Ball(world, sp_ball, 390, 290)
ball.velocity.vx = -BALL_SPEED
collision.ball = ball
aicontroller.ball = ball
running = True
while running:
for event in video.get_events():
if event.type == sdlevents.SDL_QUIT:
running = False
break
if event.type == sdlevents.SDL_KEYDOWN:
if event.key.keysym.sym == sdlkc.SDLK_UP:
player1.velocity.vy = -PADDLE_SPEED
elif event.key.keysym.sym == sdlkc.SDLK_DOWN:
player1.velocity.vy = PADDLE_SPEED
elif event.type == sdlevents.SDL_KEYUP:
if event.key.keysym.sym in (sdlkc.SDLK_UP, sdlkc.SDLK_DOWN):
player1.velocity.vy = 0
sdltimer.delay(10)
world.process()
def run(self, window):
"""Starts an event loop without actually processing any event.
"""
running = True
while running:
event = events.poll_event(True)
while event is not None:
if event.type == events.SDL_QUIT:
running = False
break
window.refresh()
timer.delay(10)
def loop(window, bg_color, fbo_color, grid, hud, panels, choke):
fbo = FBO(Size2(window._w, window._h))
choke_ms = 0 if choke == 0 else 1000 // choke
while True:
loopstart = sdltimer.get_ticks()
while True:
event = sdlevents.poll_event(True)
if event is None:
break
elif event.type == sdlevents.SDL_QUIT:
return
elif event.type == sdlevents.SDL_KEYUP:
if event.key.keysym.sym == sdlkeys.SDLK_ESCAPE:
return
elif event.type == sdlevents.SDL_WINDOWEVENT:
if event.window.event == sdlvideo.SDL_WINDOWEVENT_RESIZED:
sz = Size2(event.window.data1, event.window.data2)
fbo.resize(sz)
grid.reshape(sz)
hud.reshape(sz)
elif event.type == sdlevents.SDL_MOUSEBUTTONDOWN:
return
glcalltrace("frame")
glClearColor(*bg_color)
glClear(GL_COLOR_BUFFER_BIT)
glcalltrace("fbo.bind()")
fbo.bind(fbo_color)
glcalltrace("grid.render()")
grid.render()
glcalltrace("fbo.blit()")
fbo.blit(Rect(0, 0, window._w, window._h))
glcalltrace("hud.render()")
hud.render(panels)
sdl_flip(window)
elapsed = sdltimer.get_ticks() - loopstart
if choke_ms > elapsed:
sdltimer.delay(choke_ms - elapsed)
def test_add_remove_timer(self):
calls = []
def timerfunc(interval, param):
calls.append(param)
return interval
callback = timer.SDL_TimerCallback(timerfunc)
timerid = timer.add_timer(100, callback, "Test")
start = timer.get_ticks()
end = start
while(end - start) < 1100:
# One second wait
end = timer.get_ticks()
# check for <=11, since it can happen that a last call is still
# executing
self.assertLessEqual(len(calls), 11)
timer.remove_timer(timerid)
self.assertLessEqual(len(calls), 11)
timer.remove_timer(timerid)
# Wait a bit, so the last executing handlers can finish
timer.delay(10)
def loop(self, choke):
frame_no = 0
last_loop_ts = last_animflip_ts = sdltimer.get_ticks() - 1
render_choke = 1000/choke if choke > 0 else 0 # ala G_FPS_CAP
anim_period = 1000/self.anim_fps
paused = False
finished = False
panning = False
scrolldict = { SDLK_LEFT: ( 1, 0),
SDLK_RIGHT: ( -1, 0),
SDLK_UP: ( 0, 1),
SDLK_DOWN: ( 0, -1),
SDLK_HOME: ( 1, 1),
SDLK_PAGEUP: ( -1, 1),
SDLK_END: ( 1, -1),
SDLK_PAGEDOWN: ( -1, -1), }
def had_input():
if not self.had_input:
self.had_input = True
self.hp_cheat.active = False
while not finished:
loop_start = sdltimer.get_ticks()
self.last_loop_time = loop_start - last_loop_ts
last_loop_ts = loop_start
if not paused:
if loop_start - last_animflip_ts > anim_period:
frame_no += 1
last_animflip_ts = loop_start
if frame_no > self.gamedata.maxframes-1:
frame_no = 0
self.render(frame_no)
while not finished: # hang around in case fps is user-limited
while True: # eat events
ev = sdlevents.poll_event(True)
kmodstate = sdlkeyboard.get_mod_state()
if ev is None:
break
elif ev.type == SDL_KEYDOWN:
kcode = ev.key.keysym.sym
if kcode == SDLK_SPACE:
paused = not paused
elif kcode == SDLK_F1:
self.hp_cheat.active = not self.hp_cheat.active
elif kcode == SDLK_F2:
self.dump_fbos()
elif kcode == SDLK_ESCAPE:
if self.had_input:
finished = True
break
else:
self.hp_cheat.active = False
elif kcode == SDLK_KP_MULTIPLY:
self.show_hidden = False if self.show_hidden else True
elif kcode in (SDLK_KP_DIVIDE, SDLK_BACKQUOTE):
self.hp_debug.active = False if self.hp_debug.active else True
elif kcode == SDLK_PERIOD and ev.mod & KMOD_SHIFT:
self.zpan(-1)
elif kcode == SDLK_COMMA and ev.mod & KMOD_SHIFT:
self.zpan(1)
elif kcode in scrolldict:
boost = 10 if kmodstate & KMOD_SHIFT else 1
self.pan(Coord2(scrolldict[kcode][0] * boost * self.psz.x,
scrolldict[kcode][1] * boost * self.psz.y))
elif kcode == SDLK_BACKSPACE:
self.render_origin = self.gamedata.window
elif kcode == SDLK_KP_PLUS:
if self.anim_fps > 1:
self.anim_fps += 1
elif self.anim_fps > 0.5:
self.anim_fps = 1
else:
self.anim_fps *= 2
anim_period = 1000.0 / self.anim_fps
elif kcode == SDLK_KP_MINUS:
if self.anim_fps > 1:
self.anim_fps -= 1
else:
self.anim_fps /= 2
anim_period = 1000.0 / self.anim_fps
elif kcode == SDLK_MINUS:
if self.zeddown > 1:
self.zeddown -= 1
elif kcode == SDLK_EQUALS:
if self.zeddown < self.gamedata.dim.z - 1:
self.zeddown += 1
had_input()
elif ev.type == SDL_QUIT:
finished = True
break
elif ev.type == SDL_WINDOWEVENT:
if ev.window.event == sdlvideo.SDL_WINDOWEVENT_RESIZED:
self.reshape(Size2(ev.window.data1, ev.window.data2))
elif ev.type == SDL_MOUSEBUTTONDOWN:
had_input()
if ev.button.button == SDL_BUTTON_RIGHT: # RMB
panning = True
elif ev.button.button == SDL_BUTTON_LEFT:
paused = not paused
elif ev.type == SDL_MOUSEBUTTONUP:
if ev.button.button == SDL_BUTTON_RIGHT:
panning = False
elif ev.type == SDL_MOUSEMOTION:
if panning:
self.pan(Coord2(ev.motion.xrel, ev.motion.yrel))
elif ev.type == SDL_MOUSEWHEEL:
had_input()
amount = -ev.wheel.y
mpos = Coord2._make(sdlmouse.get_mouse_state()[1:])
if kmodstate & KMOD_CTRL:
if amount > 0:
self.zoom("zoom_in", mpos)
else:
self.zoom("zoom_out", mpos)
elif kmodstate & KMOD_SHIFT:
self.zpan(10 * amount)
else:
self.zpan(1 * amount)
elapsed_time = sdltimer.get_ticks() - last_loop_ts
if elapsed_time > render_choke:
break
sdltimer.delay(10)
def loop(self, window, bg_color, choke):
self.resize(Size2(window._w, window._h))
blit = Blitter()
choke_ms = 0 if choke == 0 else 1000//choke
while True:
loopstart = sdltimer.get_ticks()
while True:
event = sdlevents.poll_event(True)
if event is None:
break
elif event.type == sdlevents.SDL_QUIT:
return
elif event.type == sdlevents.SDL_KEYUP:
if event.key.keysym.sym == sdlkeys.SDLK_ESCAPE:
return
elif event.type == sdlevents.SDL_WINDOWEVENT:
if event.window.event == sdlvideo.SDL_WINDOWEVENT_RESIZED:
self.resize(Size2(event.window.data1, event.window.data2))
elif event.type == sdlevents.SDL_MOUSEBUTTONDOWN:
return
glcalltrace("frame")
renderlist = self.gather()
#pprint.pprint(renderlist)
text_sizes = {}
map_sizes = {}
for what, rect in renderlist:
if isinstance(what, Text):
text_sizes[what] = what.size
elif isinstance(what, Mapview0):
glcalltrace("create mapview fbo")
map_sizes[what] = TexFBO(what.size)
glcalltrace("create text surfbunchpbo")
text_surf_bunch = SurfBunchPBO(text_sizes, FtBitmap)
# 1. submit text_surf_bunch for text rendering
for what, ts in text_surf_bunch.items():
what.render(ts.surface)
# 2. render maps
for what, where in map_sizes.items():
glcalltrace("render mapview")
with where.as_target():
what.render()
# 3. wait for text rendering to be complete
pass
glcalltrace("upload text textures")
text_surf_bunch.upload()
# 3. compose
vpsize = Size2(window._w, window._h)
glcalltrace("compose")
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glViewport(0, 0, *vpsize)
glClearColor(*bg_color)
glClear(GL_COLOR_BUFFER_BIT)
for what, rect in renderlist:
if what in text_surf_bunch:
glcalltrace("blit text")
glActiveTexture(GL_TEXTURE0) # in fact here we can get away
# with calling this outside the loop
# but only here. It's noop after
# the first call (in mesa) anyway.
glBindTexture(GL_TEXTURE_2D, text_surf_bunch[what].texname)
blit.ralpha(rect, vpsize, color=(1.0,1.0,1.0,1.0))
elif isinstance(what, Panel):
glcalltrace("blit panel")
blit.fill(rect, vpsize, what.color)
elif what in map_sizes:
glcalltrace("blit mapview")
with map_sizes[what].as_texture(GL_TEXTURE0):
blit.texblend(rect, vpsize)
sdl_flip(window)
text_surf_bunch.fini()
for tf in map_sizes.values():
tf.fini()
#return
elapsed = sdltimer.get_ticks() - loopstart
if choke_ms > elapsed:
sdltimer.delay(choke_ms - elapsed)
