def test_assets_search_path(self, mock_exists, mock_glob, mock_sys,
mock_usr):
mock_sys = []
mock_usr = []
self.mock_self.pathmaps = {}
mock_exists.return_value = True
path = Assets._search_path(self.mock_self, "testpath\\testfile")
self.assertEqual(path, ["testpath\\testfile"])
mock_exists.assert_called_once_with("testpath\\testfile")
mock_exists.call_count = 0
self.assertEqual(mock_glob.glob.call_count, 0)
mock_exists.return_value = False
path = Assets._search_path(self.mock_self, "testpath\\testfile")
self.assertEqual(path, ["testpath\\testfile"])
mock_exists.assert_called_once_with("testpath\\testfile")
self.assertEqual(mock_glob.glob.call_count, 0)
mock_glob.glob.return_value = [1, 2, 3]
path = Assets._search_path(self.mock_self, "testpath\\*\\testfile")
mock_glob.glob.assert_called_with("testpath\\*\\testfile")
self.assertEqual(path, [1, 2, 3])
mock_glob.glob.return_value = []
path = Assets._search_path(self.mock_self, "testpath\\[0-9]testfile")
mock_glob.glob.assert_any_call("testpath\\[0-9]testfile")
self.assertEqual(path, ["testpath\\[0-9]testfile"])
def download(message):
global downloader
global getlist
global logger
package_list = message['list']
for package_name in message['list']:
asset = Assets()
info = getlist.result[package_name]
if not asset.exist(package_name):
asset.add(package_name, info['title'],
int(info['popular'].replace(",", "")), info['category'])
asset.close()
else:
ass = asset.get(package_name)
if ass['popular'] < int(info['popular'].replace(",", "")):
asset.update_asset(package_name,
['title', 'popular', 'category'], [
info['title'],
int(info['popular'].replace(",", "")),
info['category'], package_name
])
try:
logger.start()
socketio.start_background_task(target=downloader.download_packages,
package_list=package_list,
logger=logger.logger)
for a in logger.loggenerator():
data = json.loads(a)
if data['step'] == "complete":
time.sleep(1)
logger.stop()
socketio.emit("download_step", data, namespace="/apk_download")
except Exception as e:
print(e)
logger.stop()
def awstest_layout(package_name):
asset = Assets()
ass = asset.get(package_name)
dic_service = []
for s in ass['service'].split(","):
dic_service.append("/static/icons/AWS-"+s+".svg")
return render_template("awstest.html", services=dic_service)
def show_categories():
update('browse', 'Categories')
if not settings.use_local_db:
asset = Assets(db_file, backup_db_file)
if asset.is_old():
asset.update(settings.url_db)
log("Loading data from DB file: %s" % db_file)
try:
conn = sqlite3.connect(db_file)
cursor = conn.execute('''SELECT * FROM categories''')
li = xbmcgui.ListItem('Всички')
url = make_url({"id": 0, "action": "show_channels"})
xbmcplugin.addDirectoryItem(int(sys.argv[1]), url, li, True)
#Add categories
for row in cursor:
li = xbmcgui.ListItem(row[1])
url = make_url({"id": row[0], "action": "show_channels"})
xbmcplugin.addDirectoryItem(int(sys.argv[1]), url, li, True)
except Exception as er:
log(er, xbmc.LOGERROR)
show_notification(str(er), True)
if not settings.use_local_db:
li = xbmcgui.ListItem('******** Обнови базата данни ********')
url = make_url({"action": "update_tvdb"})
xbmcplugin.addDirectoryItem(int(sys.argv[1]), url, li)
xbmcplugin.endOfDirectory(int(sys.argv[1]))
def test_yearBase(self):
length = 30
gk = GuytonKlinger(.05, True, True, True, True, length)
gk.reset(Portfolio(Assets(.5, .5)))
# withdraw and grow once
initialWithdrawal = gk.withdraw(1.0, 12)
initialPortfolio = gk.getPortfolioValue()
gk.grow(Assets(1.1, 1.1))
# now do it 11 more times
for i in range(1, 12):
withdrawal = gk.withdraw(1.0, 12)
gk.grow(Assets(1.1, 1.1))
portfolio = gk.getPortfolioValue()
self.assertAlmostEqual(withdrawal, initialWithdrawal, delta=.0005)
self.assertAlmostEqual(portfolio,
initialPortfolio - (i * initialWithdrawal),
delta=.0005)
# now do it 1 more time, which will trigger the new year calculations.
grownWithdrawal = gk.withdraw(1.1, 12)
gk.grow(Assets(1.1, 1.1))
grownPortfolio = gk.getPortfolioValue()
self.assertNotAlmostEqual(grownWithdrawal,
initialWithdrawal,
delta=.00005)
self.assertNotAlmostEqual(grownPortfolio,
initialPortfolio,
delta=.00005)
def local_multiplayer(assets_obj: assets.Assets, ui_obj: assets.UserInterface):
"""Local multiplayer inputs handler"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
assets_obj.player.speed -= assets_obj.player.control_speed
if event.key == pygame.K_DOWN:
assets_obj.player.speed += assets_obj.player.control_speed
if event.key == pygame.K_w:
assets_obj.opponent.speed -= assets_obj.opponent.control_speed
if event.key == pygame.K_s:
assets_obj.opponent.speed += assets_obj.opponent.control_speed
if event.key == pygame.K_ESCAPE:
ui_obj.current_menu = "TITLE SCREEN"
print("end local multiplayer")
assets_obj.reset()
if event.type == pygame.KEYUP:
if event.key == pygame.K_UP:
assets_obj.player.speed += assets_obj.player.control_speed
if event.key == pygame.K_DOWN:
assets_obj.player.speed -= assets_obj.player.control_speed
if event.key == pygame.K_w:
assets_obj.opponent.speed += assets_obj.opponent.control_speed
if event.key == pygame.K_s:
assets_obj.opponent.speed -= assets_obj.opponent.control_speed
def awstest(package_name, keys):
at.set_keys(package_name, keys['access_key_id'], keys['secret_key_id'],
keys['session_token'], keys['region'])
auto_check = False
isvuln = False
for service in keys['service'].split(","):
if service == "s3":
auto_check = True
isvuln = isvuln or at.s3_check(keys['bucket'], "ls")
elif service == "kinesis":
auto_check = True
isvuln = isvuln or at.kinesis_check("list_streams")
elif service == "firehose":
auto_check = True
isvuln = isvuln or at.firehose_check("list_delivery_streams")
asset = Assets()
asset.update_one(package_name, "vulnerable", 1 if isvuln else 0)
if not auto_check:
socketio.emit("log", {
"service":
"auto_check",
"type":
"no",
"msg":
"[!] This app is not using \"s3\", \"kinesis\", \"firehose\"."
},
namespace="/awstest")
socketio.emit("manual_log", {"data": "[!] AWS Configuration Start!!"},
namespace="/awstest")
at.configure()
socketio.emit("manual_log", {"data": "[!] AWS Configuration Complete!"},
namespace="/awstest")
def awstest_start(message):
global logger
global at
package_name = message['package_name']
asset = Assets()
keys = asset.get(package_name)
logger.start()
socketio.start_background_task(target=awstest,
package_name=package_name,
keys=keys)
isvuln = False
for a in logger.loggenerator():
data = json.loads(a)
if data['service'] == "stop":
time.sleep(0.5)
logger.stop()
break
elif data['type'] == "vuln":
isvuln = isvuln or True
elif data['type'] == "novuln":
isvuln = isvuln or False
socketio.emit("log", data, namespace="/awstest")
asset.update_one(package_name, "vulnerable", 1 if isvuln else 0)
at = awsTester(package_name, keys['access_key_id'], keys['secret_key_id'],
keys['session_token'], keys['region'])
socketio.emit("manual_log", {"data": "[!] AWS Configuration Start!!"},
namespace="/awstest")
at.configure()
socketio.emit("manual_log", {"data": "[!] AWS Configuration Complete!"},
namespace="/awstest")
def awstest_start(message):
package_name = message['package_name']
asset = Assets()
keys = asset.get(package_name)
socketio.start_background_task(target=awstest,
package_name=package_name,
keys=keys)
def test_assets_get_textures(self, mock_maya, mock_asset):
mock_asset.return_value = mock.create_autospec(Asset)
mock_asset.return_value.is_duplicate.return_value = True
self.mock_self._search_path.return_value = ["a"]
class TestIter(object):
def __init__(self):
self.current = None
self.itr = iter(range(0, 5))
def is_done(self):
try:
self.current = self.itr.next()
return False
except StopIteration:
return True
def get_references(self):
return ["dir1/1", "dir2/2", "dir3/3"]
mock_maya.dependency_nodes.return_value = TestIter()
tex = Assets._get_textures(self.mock_self)
self.assertEqual(tex, [])
self.assertEqual(mock_asset.call_count, 15)
mock_asset.assert_called_with("a", [], self.mock_self.batch,
self.mock_self._log)
mock_asset.return_value.is_duplicate.return_value = False
mock_maya.dependency_nodes.return_value = TestIter()
tex = Assets._get_textures(self.mock_self)
self.assertEqual(len(tex), 15)
def startdownload(self, pkgid="", logger=""):
self.pkgid = pkgid
if self.pkgid == "":
return
self.asset = Assets()
self.asset.update_status(self.pkgid, "downloading")
print('\nAttempting to download %s\n' % self.pkgid)
logger.info(json.dumps({"step":"start","package":self.pkgid}))
try:
fl = ""
for codename in self.devices_codenames:
self.server = GooglePlayAPI('ko_KR', 'Asia/Seoul', device_codename=codename)
self.server.login(None, None, self.gsfId, self.authSubToken)
try:
fl = self.server.download(self.pkgid)
break
except Exception as e:
continue
if fl == "":
raise Exception("No Device")
with open(self.apkfile_path + self.pkgid + '.apk', 'wb') as apk_file:
for chunk in fl.get('file').get('data'):
apk_file.write(chunk)
print('\n[+] Download successful\n')
logger.info(json.dumps({"step":"finish","package":self.pkgid}))
self.asset.update_status(self.pkgid, "downloaded")
logger.info(json.dumps({"step":"check","package":self.pkgid}))
self.check_aws_sdk_common(self.pkgid, logger)
except :
print("Unexpected error:", sys.exc_info()[0])
traceback.print_exc()
#time.sleep(3)
pass
def __init__(self, name=None):
self._running = True
self._display_surf = None
self.size = self.weight, self.height = 640, 480
self.name = name or 'pw19'
self.assets = Assets()
self._map = Map()
debug('main init done')
def select_remove(message):
asset = Assets()
for package in message['list']:
try:
os.remove(os.path.join("./tmp/") + package + '.apk')
except:
pass
socketio.emit("remove_result", {"result":asset.delete_one(package),"package":package}, namespace="/assets")
def test_ramp(self):
i = 1000000
result = runSimulation(30, i, i * 0.04,
((ConstantWithdrawalAmountStrategy(i * .04),
LinearRamp(Assets(.8, .2), Assets(.2, .8),
(30 + 1) * 12), 1.0), ), 1926,
1997)
self.assertAlmostEqual(result.getSuccessRate(), .98, delta=.005)
def test_multipleStrategies(self):
i = 1000000
result = runSimulation(30, i, i * 0.04,
((ConstantWithdrawalAmountStrategy(
i * .04 * .6), Assets(.5, .5), .6),
(ConstantWithdrawalAmountStrategy(
i * .04 * .4), Assets(.5, .5), .4)), 1926,
1997)
self.assertAlmostEqual(result.getSuccessRate(), .95, delta=.005)
def test_multipleDifferentStrategies(self):
i = 1000000
result = runSimulation(
30, i, 0.0,
((ConstantWithdrawalAmountStrategy(i * .04 * .5), Assets(.5,
.5), .5),
(ConstantPercentWithdrawalStrategy(.10), Assets(1.0, 0.0), .5)),
1926, 2009)
# it always works because you never run out with a percent withdrwawal strategy
self.assertAlmostEqual(result.getSuccessRate(), 1.0, delta=.005)
def network_disconnect(self, assets_obj: assets.Assets,
ui_obj: assets.UserInterface):
"""Use in client to end multiplayer mode"""
self.flag['is_binded'] = False
self.flag['is_game_running'] = False
assets_obj.reset()
ui_obj.current_menu = "TITLE SCREEN"
try:
self.socket.close()
except (socket.error, OSError, ValueError) as msg:
print(f"{msg} at network_disconnect")
def test_assets_gather(self):
self.mock_self.refs = []
self.mock_self._get_textures.return_value = ['a']
self.mock_self._get_caches.return_value = ['b']
self.mock_self._get_references.return_value = ['c']
Assets.gather(self.mock_self)
self.assertEqual(self.mock_self.refs, ['a', 'b', 'c'])
self.assertEqual(self.mock_self._get_textures.call_count, 1)
self.assertEqual(self.mock_self._get_caches.call_count, 1)
self.assertEqual(self.mock_self._get_references.call_count, 1)
def __init__(self, loss_tolerance, liquid_assets=0, invested_assets=0):
self.assets = Assets(liquid_assets, invested_assets)
self.price = Prices()
self.price_watcher = PriceWatcher(self)
self.initial_investment = None
self.loss_tolerance = loss_tolerance
self.loss_tolerance_price = None
self.gain_threshold_met = False
self.assets_are_liquid = True
self.is_trading = True
self.first_trade = True
def test_basicWithdrawal(self):
length = 30
gk = GuytonKlinger(.05, True, True, True, True, length)
gk.reset(Portfolio(Assets(.5, .5)))
withdrawal = gk.yearWithdraw(1.0)
self.assertAlmostEqual(withdrawal, .05, delta=.005)
gk.reset(Portfolio(Assets(.5, .5)))
monthlyWithdrawals = 0.0
for i in range(0, 12):
monthlyWithdrawals += gk.withdraw(1.0, 12)
self.assertAlmostEqual(withdrawal, monthlyWithdrawals, delta=.005)
def end_hosting(self, assets_obj: assets.Assets,
ui_obj: assets.UserInterface):
"""Use in server to end multiplayer mode"""
self.flag['is_binded'] = False
self.flag['is_game_running'] = False
assets_obj.reset()
ui_obj.current_menu = "TITLE SCREEN"
try:
self.socket.shutdown(socket.SHUT_RDWR)
except (socket.error, OSError, ValueError) as msg:
print(f"{msg} at end_hosting")
self.socket.close()
def download(message):
package_list = message['list']
for package_name in message['list']:
asset = Assets()
info = getlist.result[package_name]
if not asset.exist(package_name):
asset.add(package_name, info['title'], int(info['popular'].replace(",","")), info['category'])
asset.close()
else:
ass = asset.get(package_name)
if ass['popular'] < int(info['popular'].replace(",","")):
asset.update_asset(package_name, ['title', 'popular', 'category'], [info['title'], int(info['popular'].replace(",","")), info['category'], package_name])
socketio.start_background_task(target=downloader.download_packages, package_list=package_list)
def test_linearRampNegative(self):
start = Assets(1.0, 0.0)
end = Assets(0.2, 1.0)
ramp = LinearRamp(start, end, 10)
gotException = False
try:
for allocation in ramp:
pass
except:
gotException = True
self.assertTrue(gotException)
def startdownload(self, pkgid):
self.pkgid = pkgid
self.asset = Assets()
self.asset.update_status(self.pkgid, "downloading")
print('\nAttempting to download %s\n' % self.pkgid)
self.emit("download_step", {"step": "start", "package": self.pkgid})
try:
fl = ""
for codename in self.devices_codenames:
self.server = GooglePlayAPI(self.locale,
self.timezone,
device_codename=codename,
proxies_config=self.proxy)
self.server.login(None, None, self.gsfId, self.authSubToken)
try:
fl = self.server.download(self.pkgid)
if fl == "":
raise Exception("No Device")
with open(self.apkfile_path + self.pkgid + '.apk',
'wb') as apk_file:
for chunk in fl.get('file').get('data'):
apk_file.write(chunk)
print('\n[+] Download successful\n')
self.emit("download_step", {
"step": "finish",
"package": self.pkgid
})
self.asset.update_status(self.pkgid, "downloaded")
self.emit("download_step", {
"step": "check",
"package": self.pkgid
})
self.check_aws_sdk_common(self.pkgid)
break
except requests.exceptions.SSLError:
self.emit("download_step", {
"step": "error",
"msg": "sslerror",
"package": self.pkgid
})
print("requests.exceptions.SSLError")
break
except Exception:
traceback.print_exc()
continue
except:
print("Unexpected error:", sys.exc_info()[0])
traceback.print_exc()
#time.sleep(3)
pass
def test_assets_collect(self):
self.mock_self.refs = []
files = Assets.collect(self.mock_self)
self.assertEqual(files, [])
test_file = mock.create_autospec(Asset)
test_file.included.return_value = True
self.mock_self.refs = [test_file]
files = Assets.collect(self.mock_self)
test_file.included.assert_called_once_with()
self.assertEqual(files, [test_file])
test_file.included.return_value = False
files = Assets.collect(self.mock_self)
self.assertEqual(files, [])
def test_linearRamp(self):
for i in [2, 10, 30, 80]:
start = Assets(1.0, 0.0)
end = Assets(0.0, 1.0)
ramp = LinearRamp(start, end, i)
count = 0
allocations = []
for allocation in ramp:
count += 1
allocations.append(allocation)
self.assertEqual(allocations[0], start)
self.assertEqual(allocations[-1], end)
self.assertEqual(count, i)
def assets(self):
"""
"""
if self._assets is None:
from assets import Assets
self._assets = Assets(self)
return self._assets
def test_constantPercentRegression(self):
result = runSimulation(
30, 1.0, .1,
((ConstantPercentWithdrawalStrategy(.1), Assets(.5, .5), 1.0), ),
1926, 1997)
self.assertLessEqual(result.getSuccessRate(), .95)
def test_largePortfolio(self):
i = 1000000
result = runSimulation(30, i, i * 0.04,
((ConstantWithdrawalAmountStrategy(i * .04),
Assets(.5, .5), 1.0), ), 1926, 1997)
self.assertAlmostEqual(result.getSuccessRate(), .95, delta=.005)
def __init__(self):
self.asset = Assets()
parser.read(self.asset.configuration_path)
self.current_turn = 'Goat'
self.winner = None
self.goats_in_hand = 20
self.goats_killed = 0
self.player_1 = Player("Goat", parser.get("settings", "Goat"))
self.player_2 = Player("Tiger", parser.get("settings", "Tiger"))
self.depth = 4
self.set_difficulty()
self.ai = None
self.role = dict()
self.role["Goat"] = "Human"
self.role["Tiger"] = "Human"
if self.player_1.type == "AI":
self.ai = "Goat"
self.role["Goat"] = "AI"
elif self.player_2.type == "AI":
self.ai = "Tiger"
self.role["Tiger"] = "AI"
self.grid = None
self.board_init()
def __init__(self, name=None):
self._running = True
self._display_surf = None
self.size = self.weight, self.height = 640, 480
self.name = name or 'pw19'
self.assets = Assets()
self._map = Map()
debug('main init done')
class App:
def __init__(self, name=None):
self._running = True
self._display_surf = None
self.size = self.weight, self.height = 640, 480
self.name = name or 'pw19'
self.assets = Assets()
self._map = Map()
debug('main init done')
def on_init(self):
debug('on_init started')
pygame.init()
self.assets.load_all()
# load icon and set it
# icon = pygame.image.load(os.path.join('.', 'afuckingbeachballright_icon.png'))
pygame.display.set_icon(self.assets['application_icon'])
pygame.display.set_caption(self.name)
self._surf = pygame.display.set_mode(self.size, pygame.HWSURFACE | pygame.DOUBLEBUF)
self._running = True
debug('on_init done')
def test(self):
debug('test started')
# just a method in which I test some code :)
self._surf.fill(Color('white'))
pygame.draw.rect(self._surf, Color('black') , Rect(9,9,322+16,242), 1)
pygame.display.flip()
time.sleep(0.1) # I want to see the process... :)
map = self._surf.subsurface(Rect(10,10,320+16,240))
map.fill(Color('grey'))
pygame.display.flip()
time.sleep(0.1) # I want to see the process... :)
map.blit(self.assets['tile1'], (10,10))
pygame.display.flip()
time.sleep(0.1) # I want to see the process... :)
map.blit(self.assets['tile1'], (-5,-5))
map.blit(self.assets['tile1'], (355,235))
pygame.display.flip()
pool = ['tile1', 'tile2', 'tile3', 'tile4']
map_height = 32
map_width = 32
random_map = [[random.choice(pool) for i in xrange(map_width)] for j in xrange(map_height)]
random_i = [[random.randint(0,6) for i in xrange(map_width)] for j in xrange(map_height)]
scroll_x = 0
scroll_y = 0
for ix in xrange(map_width):
for iy in xrange(map_height):
offset_x = ix * 16 + scroll_x
offset_y = iy * 16 + scroll_y
map.blit(self.assets[random_map[iy][ix]], (offset_x,offset_y))
if random_i[iy][ix] == 0:
map.blit(self.assets['chair'], (offset_x,offset_y))
pygame.display.flip()
time.sleep(0.5)
self.map_area = map
self._map.set_viewport(self.map_area)
self._map.set_assets(self.assets)
self._map.generate_random_map()
self.map_area.fill(Color('white'))
self._map.render()
debug('test done')
def on_event(self, event):
if event.type == pygame.QUIT:
self._quit()
elif event.type == pygame.KEYDOWN:
if event.unicode == u'q' and (pygame.KMOD_META & event.mod):
self._quit()
def on_loop(self):
pass
def on_render(self):
pass
def on_cleanup(self):
pygame.quit()
def on_execute(self):
if self.on_init() == False:
self._running = False
self.test()
while( self._running ):
for event in pygame.event.get():
self.on_event(event)
self.on_loop()
self.on_render()
self.on_cleanup()
def _quit(self):
# quit + optional cleanup?
debug('Quitting...')
self._running = False
def run():
""" run """
sdl2.ext.common.init()
window = sdl2.ext.window.Window('', size=(640, 480))
window.show()
renderer = sdl2.ext.sprite.RenderContext(window)
factory = sdl2.ext.sprite.SpriteFactory(sdl2.ext.sprite.TEXTURE, renderer=renderer)
assets = Assets(factory)
assets.load_items()
world = FirstWorld()
player_system = PlayerSystem()
npc_system = NPCSystem(0, 0, 640, 480)
static_object_system = StaticObjectSystem()
framecount_system = FrameCountSystem()
collision_system = CollisionSystem()
viewrecive_system = ViewReciveSystem(640, 480, 1280, 1280)
view_system = ViewSystem()
render_system = RenderSystem(renderer)
background_system = BackgroundSystem(renderer)
foreground_system = ForegroundSystem(renderer)
world.add_system(player_system)
world.add_system(npc_system)
world.add_system(static_object_system)
world.add_system(collision_system)
world.add_system(viewrecive_system)
world.add_system(view_system)
world.add_system(background_system)
world.add_system(render_system)
world.add_system(foreground_system)
world.add_system(framecount_system)
user = Player(world, id_='player1', pos=(100, 100), obj_size=(32,32), sprite=assets.charactor, img_size=(32,32), ani_num=3)
npc1 = NPC(world, id_='npc1', pos=(200, 50), obj_size=(32,32), sprite=assets.npc1, img_size=(32,32), ani_num=3)
npc2 = NPC(world, id_='npc2', pos=(300, 100), obj_size=(32,32), sprite=assets.npc2, img_size=(32,32), ani_num=3, img_startpos=(32*3, 32*4))
npc3 = NPC(world, id_='npc3', pos=(50, 10), obj_size=(32,32), sprite=assets.npc1, img_size=(32,32), ani_num=3, img_startpos=(0, 32*4))
desert = Background(world, 'desert', assets.desert1, (1280, 1280))
house1 = House(world, 'house1', (410,150), (285,275), assets.house1, (85,75))
house2 = House(world, 'house2', (850,650), (285,275), assets.house1, (85,75), (608,96))
npc1.animationdata.frame_rate = 5
npc2.animationdata.frame_rate = 35
npc3.animationdata.frame_rate = 65
running = True
while running:
for event in sdl2.ext.common.get_events():
if event.type == sdl2.events.SDL_QUIT:
running = False
break
if event.type == sdl2.events.SDL_KEYDOWN:
user.charactordata.state = 1
if event.key.keysym.sym == sdl2.keycode.SDLK_UP:
user.charactordata.vy = -5
user.charactordata.direction = 3
elif event.key.keysym.sym == sdl2.keycode.SDLK_DOWN:
user.charactordata.vy = 5
user.charactordata.direction = 0
elif event.key.keysym.sym == sdl2.keycode.SDLK_LEFT:
user.charactordata.vx = -5
user.charactordata.direction = 1
elif event.key.keysym.sym == sdl2.keycode.SDLK_RIGHT:
user.charactordata.vx = 5
user.charactordata.direction = 2
elif event.type == sdl2.events.SDL_KEYUP:
if event.key.keysym.sym in (sdl2.keycode.SDLK_UP, sdl2.keycode.SDLK_DOWN, sdl2.keycode.SDLK_LEFT, sdl2.keycode.SDLK_RIGHT):
user.charactordata.vy = user.charactordata.vx = 0
user.charactordata.state = 0
world.process()
sdl2.ext.common.quit()
