def test_keypresses(self): if not self.is_interactive: py.test.skip("interactive test only") RSDL.EnableUNICODE(1) print print "Keys pressed in the Pygame window should be printed below." print " Use Escape to quit." event = lltype.malloc(RSDL.Event, flavor='raw') try: while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.KEYDOWN: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print 'Escape key' break char = rffi.getintfield(p.c_keysym, 'c_unicode') if char != 0: print 'Key:', unichr(char).encode('utf-8') else: print 'Some special key' else: print '(event of type %d)' % c_type finally: lltype.free(event, flavor='raw')
def test_poll(self): if not self.is_interactive: py.test.skip("interactive test only") import time, sys RSDL.EnableUNICODE(1) print print "Keys pressed in the Pygame window give a dot." print " Wait 3 seconds to quit." timeout = time.time() + 3 event = lltype.malloc(RSDL.Event, flavor='raw') try: while True: # busy polling ok = RSDL.PollEvent(event) ok = rffi.cast(lltype.Signed, ok) assert ok >= 0 if ok > 0: c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.KEYDOWN: sys.stderr.write('.') p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print 'Escape key' break timeout = time.time() + 3 else: if time.time() > timeout: break time.sleep(0.05) finally: lltype.free(event, flavor='raw')
def test_image_pixels(): for filename in ["demo.jpg", "demo.png"]: image = RIMG.Load(os.path.join(autopath.this_dir, filename)) assert image assert rffi.getintfield(image.c_format, 'c_BytesPerPixel') in (3, 4) RSDL.LockSurface(image) result = {} try: rgb = lltype.malloc(rffi.CArray(RSDL.Uint8), 3, flavor='raw') try: for y in range(23): for x in range(y % 13, 17, 13): color = RSDL_helper.get_pixel(image, x, y) RSDL.GetRGB(color, image.c_format, rffi.ptradd(rgb, 0), rffi.ptradd(rgb, 1), rffi.ptradd(rgb, 2)) r = rffi.cast(lltype.Signed, rgb[0]) g = rffi.cast(lltype.Signed, rgb[1]) b = rffi.cast(lltype.Signed, rgb[2]) result[x, y] = r, g, b finally: lltype.free(rgb, flavor='raw') finally: RSDL.UnlockSurface(image) RSDL.FreeSurface(image) for x, y in result: f = (x * 17 + y * 23) / float(17 * 17 + 23 * 23) expected_r = int(255.0 * (1.0 - f)) expected_g = 0 expected_b = int(255.0 * f) r, g, b = result[x, y] assert abs(r - expected_r) < 10 assert abs(g - expected_g) < 10 assert abs(b - expected_b) < 10
def setup_method(self, meth): if not conftest.option.view: py.test.skip("'--view' not specified, " "skipping tests that open a window") assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 self.screen = RSDL.SetVideoMode(640, 480, 32, 0) assert self.screen self.is_interactive = sys.stdout.isatty()
def test_fillrect_full(self): fmt = self.screen.c_format for colorname, r, g, b in [('dark red', 128, 0, 0), ('yellow', 255, 255, 0), ('blue', 0, 0, 255)]: color = RSDL.MapRGB(fmt, r, g, b) RSDL.FillRect(self.screen, lltype.nullptr(RSDL.Rect), color) RSDL.Flip(self.screen) self.check("Screen filled with %s" % colorname)
def test_surface_basic(): assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 surface = RSDL.CreateRGBSurface(0, 150, 50, 32, r_uint(0x000000FF), r_uint(0x0000FF00), r_uint(0x00FF0000), r_uint(0xFF000000)) assert surface assert rffi.getintfield(surface, 'c_w') == 150 assert rffi.getintfield(surface, 'c_h') == 50 RSDL.FreeSurface(surface) RSDL.Quit()
def test_blit_rect(self): surface = RSDL.CreateRGBSurface(0, 150, 50, 32, r_uint(0x000000FF), r_uint(0x0000FF00), r_uint(0x00FF0000), r_uint(0xFF000000)) fmt = surface.c_format color = RSDL.MapRGB(fmt, 255, 0, 0) RSDL.FillRect(surface, lltype.nullptr(RSDL.Rect), color) paintrect = RSDL_helper.mallocrect(75, 0, 150, 50) dstrect = lltype.malloc(RSDL.Rect, flavor='raw') try: color = RSDL.MapRGB(fmt, 255, 128, 0) RSDL.FillRect(surface, paintrect, color) rffi.setintfield(dstrect, 'c_x', 10) rffi.setintfield(dstrect, 'c_y', 10) rffi.setintfield(dstrect, 'c_w', 150) rffi.setintfield(dstrect, 'c_h', 50) RSDL.BlitSurface(surface, lltype.nullptr(RSDL.Rect), self.screen, dstrect) RSDL.Flip(self.screen) finally: lltype.free(dstrect, flavor='raw') lltype.free(paintrect, flavor='raw') RSDL.FreeSurface(surface) self.check("Half Red/Orange rectangle(150px * 50px) at the top left, 10 pixels from the border")
def draw(self, surf): #if self._braneRect: fmt = surf.c_format b = int(self._brane * 6) if b > 255: b = 255 elif b < 0: b = 0 color = RSDL.MapRGB(fmt, 0, 0, b) RSDL.FillRect(surf, self._braneRect, color) RSDL.FillRect(surf, self._groupRect, self._group_color) if self._draw_spike: RSDL.FillRect(surf, self._spikeRect, self._sdl_colors['white']) else: RSDL.FillRect(surf, self._spikeRect, color) #self._sdl_colors['black']) self._draw_spike = False
def test_mousemove(self): if not self.is_interactive: py.test.skip("interactive test only") print print "Move the Mouse up and down:" print " Use Escape to quit." event = lltype.malloc(RSDL.Event, flavor="raw") directions = [False]*4 try: while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, "c_type") if c_type == RSDL.MOUSEMOTION: m = rffi.cast(RSDL.MouseMotionEventPtr, event) assert rffi.getintfield(m, "c_x") >= 0 assert rffi.getintfield(m, "c_y") >= 0 print rffi.getintfield(m, "c_xrel") directions[0] |= rffi.getintfield(m, "c_xrel")>0 directions[1] |= rffi.getintfield(m, "c_xrel")<0 directions[2] |= rffi.getintfield(m, "c_yrel")>0 directions[3] |= rffi.getintfield(m, "c_yrel")<0 if False not in directions: break elif c_type == RSDL.KEYUP: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print " test manually aborted" py.test.fail(" mousemovement test aborted") break finally: lltype.free(event, flavor='raw')
def test_load_image(): for filename in ["demo.jpg", "demo.png"]: image = RIMG.Load(os.path.join(autopath.this_dir, filename)) assert image assert rffi.getintfield(image, 'c_w') == 17 assert rffi.getintfield(image, 'c_h') == 23 RSDL.FreeSurface(image)
def setup_draw(self, format, braneRect, groupRect, spikeRect, colors): self._braneRect = braneRect self._groupRect = groupRect self._spikeRect = spikeRect self._sdl_colors = colors r, g, b = self._color self._group_color = RSDL.MapRGB(format, int(r * 255), int(g * 255), int(b * 255))
def test_bit_pattern(self): HEIGHT = WIDTH = 10 fmt = self.screen.c_format white = RSDL.MapRGB(fmt, 255, 255, 255) black = RSDL.MapRGB(fmt, 0, 0, 0) RSDL.LockSurface(self.screen) for i in xrange(WIDTH): for j in xrange(HEIGHT): k = j*WIDTH + i if k % 2: c = white else: c = black RSDL_helper.set_pixel(self.screen, i, j, c) RSDL.UnlockSurface(self.screen) RSDL.Flip(self.screen) self.check("Upper left corner 10x10 field with vertical black/white stripes")
def test_set_color_key(self): # prepare fillrect = RSDL_helper.mallocrect(10, 10, 30, 30) RSDL.FillRect(self.src_surf, fillrect, self.blue) lltype.free(fillrect, flavor='raw') assert RSDL.SetColorKey(self.src_surf, RSDL.SRCCOLORKEY, self.blue) == 0 # draw RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 0, 0) # check for position, color in (((0, 0), self.red), ((10, 10), self.black), ((20, 20), self.black), ((40, 40), self.red)): fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0], position[1]) assert fetched_color == color
def test_load_wav(): if RMix.OpenAudio(22050, RSDL.AUDIO_S16LSB, 2, 1024) != 0: error = rffi.charp2str(RSDL.GetError()) raise Exception(error) filename = rffi.str2charp('applause.wav') RMix.LoadWAV(filename) rffi.free_charp(filename) RMix.CloseAudio()
def test_play_wav(): if RMix.OpenAudio(22050, RSDL.AUDIO_S16LSB, 2, 1024) != 0: error = rffi.charp2str(RSDL.GetError()) raise Exception(error) filename = rffi.str2charp('applause.wav') applause = RMix.LoadWAV(filename) rffi.free_charp(filename) RMix.PlayChannel(-1, applause, -1) time.sleep(1) RMix.CloseAudio()
def update(self, event): # fetch the event from sdl ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 type = rffi.getintfield(event, 'c_type') if type == RSDL.KEYDOWN: self.create_called_key() self.on_key_down() elif type == RSDL.KEYUP: self.create_called_key() self.on_key_up()
def entry_point(argv=None): RSDL.Init(RSDL.INIT_VIDEO) >= 0 screen = RSDL.SetVideoMode(WIDTH, HEIGHT, 32, 0) event = lltype.malloc(RSDL.Event, flavor='raw') paintpattern = 0 try: while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.KEYDOWN: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print 'Escape key' break paintpattern += 1 update_screen(screen, paintpattern) finally: lltype.free(event, flavor='raw') return 0
def loop(self): self._active = True fmt = self.screen.c_format RSDL.FillRect(self.screen, lltype.nullptr(RSDL.Rect), self.ColorGrey) layers = self._layers neurons = self._neurons pulse_layers = self._pulse_layers screen = self.screen loops = 0 now = start = float(time.time()) while self._active: #Bjitdriver.can_enter_jit( layers=layers, neurons=neurons, pulse_layers=pulse_layers, loops=loops ) #Bjitdriver.jit_merge_point( layers=layers, neurons=neurons, pulse_layers=pulse_layers, loops=loops) now = float(time.time()) self._fps = loops / float(now - start) for i, lay in enumerate(self._layers): if self._pulse_layers[i] and False: #print 'pulse layer: %s neurons: %s ' %(i, len(lay)) for n in lay: if random() * random() > 0.8: n.spike(now) for i, col in enumerate(self._columns): if self._pulse_columns[i]: for n in col: n.spike(now) for n in self._neurons: n.iterate() n.draw(self.screen) #r,w,x = rpoll.select( [self._stdin], [], [], 1 ) # wait rl, wl, xl = rpoll.select([0], [], [], 0.000001) # wait if rl: cmd = self._stdin.readline().strip('\n').strip(' ') self.do_command(cmd) loops += 1 self._iterations = loops #print loops # can not always print in mainloop, then select can never read from stdin RSDL.Flip(self.screen) #self._fps = float(time.time()) - now #return loops return 0
def get_rgb(color, format): rgb = lltype.malloc(rffi.CArray(RSDL.Uint8), 3, flavor='raw') try: RSDL.GetRGB(color, format, rffi.ptradd(rgb, 0), rffi.ptradd(rgb, 1), rffi.ptradd(rgb, 2)) r = rffi.cast(lltype.Signed, rgb[0]) g = rffi.cast(lltype.Signed, rgb[1]) b = rffi.cast(lltype.Signed, rgb[2]) result = r, g, b finally: lltype.free(rgb, flavor='raw') return result
def mainLoop(self): self.reset() self.is_running = True try: while self.is_running and self.handle_events(): self.emulate(constants.GAMEBOY_CLOCK >> 2) time.sleep(10 / 1000) except: self.is_running = False lltype.free(self.event, flavor='raw') RSDL.Quit() self.handle_execution_error() return 0
def update_screen(screen, paintpattern): fmt = screen.c_format white = RSDL.MapRGB(fmt, 255, 255, 255) black = RSDL.MapRGB(fmt, 0, 0, 0) RSDL.LockSurface(screen) pattern[paintpattern % pl](screen, black, white) RSDL.UnlockSurface(screen) RSDL.Flip(screen) RSDL.Delay(10)
def test_set_alpha(self): # prepare assert RSDL.SetAlpha(self.src_surf, RSDL.SRCALPHA, 128) == 0 # draw RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 10, 10) RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 20, 20) # check for position, color in ( ((0, 0), (0, 0, 0)), # no rect ((10, 10), (127, 0, 0)), # one rect ((20, 20), (191, 0, 0)) # two overlapping rects ): fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0], position[1]) assert RSDL_helper.get_rgb(fetched_color, self.dst_surf.c_format) == color
def setup_method(self, meth): self.dst_surf = RSDL.CreateRGBSurface(0, 300, 300, 32, r_uint(0x000000FF), r_uint(0x0000FF00), r_uint(0x00FF0000), r_uint(0x00000000)) self.src_surf = RSDL.CreateRGBSurface(0, 50, 50, 32, r_uint(0x000000FF), r_uint(0x0000FF00), r_uint(0x00FF0000), r_uint(0x00000000)) fmt = self.src_surf.c_format self.black = RSDL.MapRGB(fmt, 0, 0, 0) self.red = RSDL.MapRGB(fmt, 255, 0, 0) self.blue = RSDL.MapRGB(fmt, 0, 0, 255) RSDL.FillRect(self.src_surf, lltype.nullptr(RSDL.Rect), self.red)
def test_mousebutton_wheel(self): if not self.is_interactive: py.test.skip("interactive test only") print print "Press the given MouseButtons:" print " Use Escape to pass tests." event_tests = [("left button", RSDL.BUTTON_LEFT), ("middle button", RSDL.BUTTON_MIDDLE), ("right button", RSDL.BUTTON_RIGHT), ("scroll up", RSDL.BUTTON_WHEELUP), ("scroll down", RSDL.BUTTON_WHEELDOWN)] test_success = [] event = lltype.malloc(RSDL.Event, flavor='raw') try: for button_test in event_tests: print " press %s:" % button_test[0] while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.MOUSEBUTTONDOWN: pass elif c_type == RSDL.MOUSEBUTTONUP: b = rffi.cast(RSDL.MouseButtonEventPtr, event) if rffi.getintfield(b, 'c_button') == button_test[1]: test_success.append(True) break elif c_type == RSDL.KEYUP: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: test_success.append(False) print " manually aborted" break #break if False in test_success: py.test.fail("") finally: lltype.free(event, flavor='raw')
def test_get_keyname(): assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 assert RSDL.GetKeyName(RSDL.K_PLUS)[0] == '+' assert RSDL.GetKeyName(RSDL.K_RIGHTPAREN)[0] == ')' assert RSDL.GetKeyName(RSDL.K_z)[0] == 'z'
def test_caption(self): RSDL.WM_SetCaption("Hello World!", "Hello World!") self.check('The window caption is "Hello World!"')
def test_show_hide_cursor(self): RSDL.ShowCursor(RSDL.DISABLE) self.check("Is the cursor hidden? ") RSDL.ShowCursor(RSDL.ENABLE) self.check("Is the cursor shown? ")
def test_delay_getticks(): assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 RSDL.Delay(10) i = RSDL.GetTicks() assert i >= 10 RSDL.Quit()
def test_sdl_init(): assert RSDL.Init(RSDL.INIT_VIDEO) >= 0 RSDL.Quit()
def teardown_method(self, meth): RSDL.Quit()