def test_SDL_INIT_HAPTIC(self):
ret = SDL_Init(SDL_INIT_HAPTIC)
if ret != 0:
self.skipTest('Haptic subsystem not supported')
ret = SDL_WasInit(SDL_INIT_HAPTIC)
self.assertEqual(ret, SDL_INIT_HAPTIC)
SDL_QuitSubSystem(SDL_INIT_HAPTIC)
def test_SDL_INIT_JOYSTICK(self):
ret = SDL_Init(SDL_INIT_JOYSTICK)
if ret != 0:
self.skipTest('Joystick subsystem not supported')
ret = SDL_WasInit(SDL_INIT_JOYSTICK)
self.assertEqual(ret, SDL_INIT_JOYSTICK)
SDL_QuitSubSystem(SDL_INIT_JOYSTICK)
def main():
screen_size = (WindowSize.WIDTH, WindowSize.HEIGHT)
SDL_Init(SDL_INIT_EVERYTHING)
window = Window("Soul Master", (WindowSize.WIDTH, WindowSize.HEIGHT))
window.show()
world = World()
sprite_renderer = None
texture_renderer = None
if RENDERER == "software":
sprite_renderer = SoftwareRenderer(window)
elif RENDERER == "texture":
texture_renderer = Renderer(window)
sprite_renderer = TextureRenderer(texture_renderer)
# world.add_system(sprite_renderer)
factory = None
if RENDERER == "software":
factory = SpriteFactory(SOFTWARE)
elif RENDERER == "texture":
factory = SpriteFactory(TEXTURE, renderer=texture_renderer)
menu = Menu(window, world, sprite_renderer, factory)
menu.run()
def test_SDL_INIT_VIDEO(self):
ret = SDL_Init(SDL_INIT_VIDEO)
if ret != 0:
self.skipTest('Video subsystem not supported')
ret = SDL_WasInit(SDL_INIT_VIDEO)
self.assertEqual(ret, SDL_INIT_VIDEO)
SDL_QuitSubSystem(SDL_INIT_VIDEO)
def test_SDL_INIT_JOYSTICK(self):
ret = SDL_Init(SDL_INIT_JOYSTICK)
if ret != 0:
pytest.skip('Joystick subsystem not supported')
ret = SDL_WasInit(SDL_INIT_JOYSTICK)
assert ret == SDL_INIT_JOYSTICK
SDL_QuitSubSystem(SDL_INIT_JOYSTICK)
def test_SDL_INIT_TIMER(self):
ret = SDL_Init(SDL_INIT_TIMER)
if ret != 0:
pytest.skip('Timer subsystem not supported')
ret = SDL_WasInit(SDL_INIT_TIMER)
assert ret == SDL_INIT_TIMER
SDL_QuitSubSystem(SDL_INIT_TIMER)
def test_SDL_INIT_VIDEO(self):
ret = SDL_Init(SDL_INIT_VIDEO)
if ret != 0:
pytest.skip('Video subsystem not supported')
ret = SDL_WasInit(SDL_INIT_VIDEO)
assert ret == SDL_INIT_VIDEO
SDL_QuitSubSystem(SDL_INIT_VIDEO)
def test_SDL_INIT_TIMER(self):
ret = SDL_Init(SDL_INIT_TIMER)
if ret != 0:
self.skipTest('Timer subsystem not supported')
ret = SDL_WasInit(SDL_INIT_TIMER)
self.assertEqual(ret, SDL_INIT_TIMER)
SDL_QuitSubSystem(SDL_INIT_TIMER)
def test_SDL_INIT_AUDIO(self):
ret = SDL_Init(SDL_INIT_AUDIO)
if ret != 0:
pytest.skip('Audio subsystem not supported')
ret = SDL_WasInit(SDL_INIT_AUDIO)
assert ret == SDL_INIT_AUDIO
SDL_QuitSubSystem(SDL_INIT_AUDIO)
def setUpClass(cls):
SDL_Init(0)
def audio_cb(userdata, audiobytes, length):
pass
cls.audiocallback = audio.SDL_AudioCallback(audio_cb)
def play(seq):
pos = 0
@SDL_AudioCallback
def cb(user, stream, length):
nonlocal pos
length = length // 8
stream = ctypes.cast(stream, ctypes.POINTER(c_float))
for i in range(length):
if pos + i < seq.shape[0]:
t = seq[pos + i]
stream[2 * i], stream[2 * i + 1] = t[0], t[-1]
else:
stream[2 * i] = stream[2 * i + 1] = 0
pos += length
if seq.ndim < 2:
seq = seq[..., np.newaxis]
if SDL_Init(SDL_INIT_AUDIO) != 0:
raise "failed"
spec = SDL_AudioSpec(seq.fs, AUDIO_F32LSB, 2, 4096, cb)
if SDL_OpenAudio(ctypes.byref(spec), None) != 0:
raise "failed"
SDL_PauseAudio(0)
while (pos < seq.shape[0]):
pass
SDL_PauseAudio(1)
SDL_CloseAudio()
SDL_Quit()
def main():
LOG.debug("INIT")
screen_size = WindowSize.WIDTH, WindowSize.HEIGHT
SDL_Init(SDL_INIT_EVERYTHING)
window = Window("CyberMotor3000", screen_size)
window.show()
world = World()
sprite_renderer = None
texture_renderer = None
if RENDERER == "software":
sprite_renderer = SoftwareRenderer(window)
elif RENDERER == "texture":
texture_renderer = Renderer(window)
sprite_renderer = TextureRenderer(texture_renderer)
factory = None
if RENDERER == "software":
factory = SpriteFactory(SOFTWARE)
elif RENDERER == "texture":
factory = SpriteFactory(TEXTURE, renderer=texture_renderer)
menu = Menu(window, world, sprite_renderer, factory)
menu.run()
def __init__(self, dots_w, dots_h, scale=1, title="PyProcGameHD", screen_position_x=0,screen_position_y=0, flags=None, blur="0"):
self.dots_w = dots_w
self.dots_h = dots_h
self.scale = scale
self.window_w = dots_w * scale
self.window_h = dots_h * scale
sdl2.ext.Window.DEFAULTPOS=(screen_position_x, screen_position_y)
SDL_Init(SDL_INIT_VIDEO)
self.window = sdl2.ext.Window(title, size=(self.window_w, self.window_h), flags=flags)
sdl2.SDL_ShowCursor(sdl2.SDL_DISABLE)
# self.window2 = sdl2.ext.Window(title, size=(self.window_w/2, self.window_h/2))
# self.window2.show()
self.window.show()
self.texture_renderer = sdl2.ext.Renderer(self.window)
sdl2.hints.SDL_SetHint(sdl2.hints.SDL_HINT_RENDER_SCALE_QUALITY, blur)
# setting scale might help if we want to use full-screen but not zoom,
# unfortunately a bug in sdl2 prevents this at present
# sc = c_float(0.8)
# sc_y = c_float(0.8)
# self.texture_renderer.scale = (sc, sc_y)
self.fill = self.texture_renderer.fill
self.clear = self.texture_renderer.clear
self.factory = sdl2.ext.SpriteFactory(renderer=self.texture_renderer)
self.font_manager = None
def test_SDL_INIT_HAPTIC(self):
ret = SDL_Init(SDL_INIT_HAPTIC)
if ret != 0:
pytest.skip('Haptic subsystem not supported')
ret = SDL_WasInit(SDL_INIT_HAPTIC)
assert ret == SDL_INIT_HAPTIC
SDL_QuitSubSystem(SDL_INIT_HAPTIC)
def test_SDL_GetAudioDeviceName(self):
devices = {}
# Reset audio subsystem
SDL_Quit()
SDL_Init(0)
for index in range(audio.SDL_GetNumAudioDrivers()):
# Get input/output device names for each audio driver
drivername = audio.SDL_GetAudioDriver(index)
os.environ["SDL_AUDIODRIVER"] = drivername.decode("utf-8")
# Need to reinitialize subsystem for each driver
SDL_InitSubSystem(SDL_INIT_AUDIO)
driver = audio.SDL_GetCurrentAudioDriver()
if driver is not None:
driver = driver.decode("utf-8")
devices[driver] = {'input': [], 'output': []}
outnum = audio.SDL_GetNumAudioDevices(False)
innum = audio.SDL_GetNumAudioDevices(True)
for x in range(outnum):
name = audio.SDL_GetAudioDeviceName(x, False)
assert name is not None
devices[driver]['output'].append(name.decode('utf-8'))
for x in range(innum):
name = audio.SDL_GetAudioDeviceName(x, True)
assert name is not None
devices[driver]['input'].append(name.decode('utf-8'))
SDL_QuitSubSystem(SDL_INIT_AUDIO)
print("Available audio drivers and devices:")
for driver in devices.keys():
print(driver)
print(" - input: {0}".format(str(devices[driver]['input'])))
print(" - output: {0}".format(str(devices[driver]['output'])))
def setup_method(self):
SDL_ClearError()
SDL_Init(SDL_INIT_AUDIO)
if os.getenv("SDL_AUDIODRIVER"):
if self.original_driver != None:
os.environ["SDL_AUDIODRIVER"] = self.original_driver
else:
os.environ.pop("SDL_AUDIODRIVER")
def setUpClass(cls):
cls._RENDERFLAGS = render.SDL_RENDERER_ACCELERATED
SDL_Init(SDL_INIT_EVERYTHING)
driver = video.SDL_GetCurrentVideoDriver()
if driver is None:
raise unittest.SkipTest('Video subsystem not supported')
if driver == b"dummy":
cls._RENDERFLAGS = render.SDL_RENDERER_SOFTWARE
def test_Mix_OpenAudio():
SDL_Init(sdl2.SDL_INIT_AUDIO)
sdlmixer.Mix_Init(0)
ret = sdlmixer.Mix_OpenAudio(22050, sdlmixer.MIX_DEFAULT_FORMAT, 2, 1024)
assert ret == 0
sdlmixer.Mix_CloseAudio()
sdlmixer.Mix_Quit()
SDL_Quit()
def test_Mix_OpenAudioDevice():
SDL_Init(sdl2.SDL_INIT_AUDIO)
sdlmixer.Mix_Init(0)
# Get names of all audio output devices for current driver
ndevices = audio.SDL_GetNumAudioDevices(0)
devices = [audio.SDL_GetAudioDeviceName(i, 0) for i in range(0, ndevices)]
# Open and close each avaliable output device
fmt = sdlmixer.MIX_DEFAULT_FORMAT
flags = audio.SDL_AUDIO_ALLOW_ANY_CHANGE
for device in devices:
ret = sdlmixer.Mix_OpenAudioDevice(22050, fmt, 2, 1024, device, flags)
assert ret == 0
sdlmixer.Mix_CloseAudio()
sdlmixer.Mix_Quit()
SDL_Quit()
def test_IMG_Init():
SDL_Init(0)
libs = {
'JPEG': sdlimage.IMG_INIT_JPG,
'PNG': sdlimage.IMG_INIT_PNG,
'TIFF': sdlimage.IMG_INIT_TIF,
'WEBP': sdlimage.IMG_INIT_WEBP
}
for lib in libs.keys():
flags = libs[lib]
ret = sdlimage.IMG_Init(flags)
err = sdlimage.IMG_GetError()
assert ret & flags == flags
sdlimage.IMG_Quit()
SDL_Quit()
def test_SDL_GetCurrentAudioDriver(self):
success = 0
# Reset audio subsystem
SDL_Quit()
SDL_Init(0)
for index in range(audio.SDL_GetNumAudioDrivers()):
drivername = audio.SDL_GetAudioDriver(index)
os.environ["SDL_AUDIODRIVER"] = drivername.decode("utf-8")
# Certain drivers fail without bringing up the correct
# return value, such as the esd, if it is not running.
SDL_InitSubSystem(SDL_INIT_AUDIO)
driver = audio.SDL_GetCurrentAudioDriver()
SDL_QuitSubSystem(SDL_INIT_AUDIO)
# Do not handle wrong return values.
if driver is not None:
assert drivername == driver
success += 1
assert success >= 1
def test_Mix_Init():
SDL_Init(sdl2.SDL_INIT_AUDIO)
supported = []
libs = {
'FLAC': sdlmixer.MIX_INIT_FLAC,
'MOD': sdlmixer.MIX_INIT_MOD,
'MP3': sdlmixer.MIX_INIT_MP3,
'OGG': sdlmixer.MIX_INIT_OGG,
'MID': sdlmixer.MIX_INIT_MID,
'OPUS': sdlmixer.MIX_INIT_OPUS
}
for lib in libs.keys():
flags = libs[lib]
ret = sdlmixer.Mix_Init(flags)
err = sdlmixer.Mix_GetError()
if ret & flags == flags:
supported.append(lib)
sdlmixer.Mix_Quit()
assert len(supported) # only fail if none supported
print("Supported formats:")
print(supported)
SDL_Quit()
def init(self) -> bool:
if SDL_Init(SDL_INIT_VIDEO) < 0:
return False
self._window = SDL_CreateWindow(GAME_TITLE, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, SDL_WINDOW_SHOWN)
if not self._window:
return False
self._renderer = SDL_CreateRenderer(self._window, -1,
SDL_RENDERER_SOFTWARE)
if not self._renderer:
return False
# Game objects
board = Board(BOARD_POSITION[0], BOARD_POSITION[1], BOARD_SIZE,
CELL_SIZE, WHITE_COLOR)
self._game_objects.append(board)
# Create piece shapes
self._pieces = PieceFactory(board)
for piece in self._pieces.create(PIECES_COUNT):
self._game_objects.append(piece)
# Create menu buttons
restart_menu = Button(b"assets/img/restart.bmp", 0, 0, 200, 50,
self._renderer, "restart_menu")
exit_menu = Button(b"assets/img/exit.bmp", SCREEN_WIDTH - 200, 0, 200,
50, self._renderer, "exit_menu")
win_box = Button(b"assets/img/win.bmp", SCREEN_WIDTH // 2 - 200,
SCREEN_HEIGHT // 2 - 100, 400, 200, self._renderer,
"win_box", False)
restart_menu.on_click = lambda: exit_menu.send("slot_restart_game")
exit_menu.on_click = lambda: exit_menu.send("slot_exit_game")
win_box.on_click = lambda: None
win_box.slot_win_game = lambda: win_box.set_show(True)
win_box.slot_restart_game = lambda: win_box.set_show(False)
self._game_objects.append(restart_menu)
self._game_objects.append(exit_menu)
self._game_objects.append(win_box)
self._running = True
return True
def setup_class(cls):
SDL_Init(sdl2.SDL_INIT_AUDIO)
# Determine supported audio formats for Mix_Init
supported = []
libs = {
'FLAC': sdlmixer.MIX_INIT_FLAC,
'MOD': sdlmixer.MIX_INIT_MOD,
'MP3': sdlmixer.MIX_INIT_MP3,
'OGG': sdlmixer.MIX_INIT_OGG,
'MID': sdlmixer.MIX_INIT_MID,
'OPUS': sdlmixer.MIX_INIT_OPUS
}
for lib in libs.keys():
flags = libs[lib]
ret = sdlmixer.Mix_Init(flags)
if ret & flags == flags:
supported.append(lib)
sdlmixer.Mix_Quit()
cls.supported = supported
# Only initialize audio formats that are supported in current binary
flaglist = [libs[lib] for lib in supported]
flags = reduce(operator.or_, flaglist) if len(flaglist) else 0
sdlmixer.Mix_Init(flags)
sdlmixer.Mix_OpenAudio(22050, sdlmixer.MIX_DEFAULT_FORMAT, 2, 1024)
def setUpClass(cls):
cls.testfile = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"resources", "surfacetest.bmp")
SDL_Init(SDL_INIT_EVERYTHING)
def main():
# install a signal handler so the script can stop safely
def signal_handler(signum, frame):
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
if tty_fd:
os.close(tty_fd)
if SDL_WasInit(SDL_INIT_JOYSTICK) == SDL_INIT_JOYSTICK:
SDL_QuitSubSystem(SDL_INIT_JOYSTICK)
SDL_Quit()
LOG.debug(f'{sys.argv[0]} exiting cleanly')
sys.exit(0)
debug_flag, hex_chars = parse_arguments(sys.argv)
if debug_flag:
LOG.setLevel(logging.DEBUG)
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
# daemonize after signal handlers are registered
if os.fork():
os._exit(0)
try:
tty_fd = os.open('/dev/tty', os.O_WRONLY)
except IOError:
LOG.error('Unable to open /dev/tty', file=sys.stderr)
sys.exit(1)
curses.setupterm()
mapped_chars = [
get_hex_chars(code) for code in hex_chars
if get_hex_chars(code) is not None
]
def_buttons = [
'left', 'right', 'up', 'down', 'a', 'b', 'x', 'y', 'pageup', 'pagedown'
]
joy_map = {}
# add for each button the mapped keycode, based on the arguments received
for i, btn in enumerate(def_buttons):
if i < len(mapped_chars):
joy_map[btn] = mapped_chars[i]
menu_swap = ra_btn_swap_config()
# if button A is <enter> and menu_swap_ok_cancel_buttons is true, swap buttons A and B functions
if menu_swap \
and 'a' in joy_map.keys() \
and 'b' in joy_map.keys() \
and joy_map['a'] == '\n':
joy_map['a'] = joy_map['b']
joy_map['b'] = '\n'
# tell SDL that we don't want to grab and lock the keyboard
os.environ['SDL_INPUT_LINUX_KEEP_KBD'] = '1'
# disable the HIDAPI joystick driver in SDL
if not (SDL_USE_HIDAPI):
os.environ['SDL_JOYSTICK_HIDAPI'] = '0'
# tell SDL to not add any signal handlers for TERM/INT
os.environ['SDL_NO_SIGNAL_HANDLERS'] = '1'
configs = get_all_ra_config(def_buttons)
if SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO) < 0:
LOG.error(f'Error in SDL_Init: {SDL_GetError()}')
exit(2)
if LOG.isEnabledFor(logging.DEBUG):
sdl_ver = version.SDL_version()
version.SDL_GetVersion(byref(sdl_ver))
wrapper_version = '.'.join(str(i) for i in version_info)
LOG.debug(
f'Using SDL Version {sdl_ver.major}.{sdl_ver.minor}.{sdl_ver.patch}, PySDL2 version {wrapper_version}'
)
if joystick.SDL_NumJoysticks() < 1:
LOG.debug(f'No available joystick devices found on startup')
event_loop(configs, joy_map, tty_fd)
SDL_QuitSubSystem(SDL_INIT_JOYSTICK)
SDL_Quit()
return 0
def setUpClass(cls):
SDL_Init(SDL_INIT_JOYSTICK)
def setUpClass(cls):
SDL_Init(SDL_INIT_VIDEO)
def setUpClass(cls):
if SDL_Init(SDL_INIT_JOYSTICK) != 0:
raise unittest.SkipTest('Joystick subsystem not supported')
cls.jcount = joystick.SDL_NumJoysticks()
def test_SDL_InitQuitAudio():
SDL_Init(0)
ret = SDL_InitSubSystem(SDL_INIT_AUDIO)
SDL_Quit()
assert ret == 0
