def process(self):
Logger.debug('[Login Challenge]: processing')
self._parse_data()
try:
current_account = AccountManager.get_account(self.account_name)
if current_account is None:
raise Exception('Account \'{}\' is not found'.format(
self.account_name))
current_account.os = self.os
current_account.ip_addr = '.'.join([str(i) for i in self.ip_addr])
current_account.platform = self.platform
current_account.timezone = self.timezone
current_account.locale = self.locale
AccountManager.update_account(current_account)
session.current_account = current_account
# TODO: define account exceptions
except Exception as e:
Logger.error('[Login Challenge]: {}'.format(e))
return None
finally:
return self._get_response()
async def process(self):
Logger.debug('[Login Challenge]: processing')
self._parse_data()
try:
account_mgr = AccountManager()
account = account_mgr.get(name=self.account_name).account
if account is None:
raise Exception('Account \'{}\' is not found'.format(
self.account_name))
account.os = self.os
account.ip = '.'.join([str(i) for i in self.ip_addr])
account.platform = self.platform
account.timezone = self.timezone
account.locale = self.locale
account_mgr.update()
self.account = account
self.temp_ref.account = account
# TODO: define account exceptions
except Exception as e:
Logger.error('[Login Challenge]: error = {}'.format(e))
return None
finally:
return self._get_response()
async def _parse_data(self):
data = await asyncio.wait_for(self.reader.read(1024), timeout=1.0)
# omit first 6 bytes, cause 01-02 = packet size, 03-04 = opcode (0x1ED), 05-06 - unknown null-bytes
tmp_buf = BytesIO(data[6:])
self.build = unpack('<H', tmp_buf.read(2))[0]
# remove next 6 unknown null-bytes (\x00)
tmp_buf.read(6)
self.account_name = self._parse_account_name(tmp_buf)
# set account for using in world packet handlers
self.temp_ref.account = AccountManager().get(name=self.account_name).account
self.client_seed = tmp_buf.read(4)
self.client_hash = tmp_buf.read(20)
def _parse_data(self):
tmp_buf = BytesIO(self.data)
# client build
tmp_buf.read(2)
# remove next 6 unknown null-bytes (\x00)
tmp_buf.read(6)
account_name = AccountNameParser.parse(tmp_buf)
with AccountManager() as account_mgr:
self.connection.account = account_mgr.get(
name=account_name).account
client_seed = tmp_buf.read(4)
client_hash = tmp_buf.read(20)
return account_name, client_seed, client_hash
async def process(self) -> tuple:
self._parse_data()
with AccountManager() as account_mgr:
account = account_mgr.get(name=self.account_name).account
if account is None:
raise Exception('Account \'{}\' is not found'.format(
self.account_name))
account.os = self.os
account.ip = '.'.join([str(i) for i in self.ip_addr])
account.platform = self.platform
account.timezone = self.timezone
account.locale = self.locale
account_mgr.update()
self.connection.account = account
return self._get_response()
async def _parse_data(self):
data = None
while not data:
try:
data = await asyncio.wait_for(self.reader.read(1024),
timeout=0.01)
except TimeoutError:
continue
else:
# omit first 6 bytes, cause 01-02 = packet size, 03-04 = opcode (0x1ED), 05-06 - unknown null-bytes
tmp_buf = BytesIO(data[6:])
self.build = unpack('<H', tmp_buf.read(2))[0]
# remove next 6 unknown null-bytes (\x00)
tmp_buf.read(6)
self.account_name = self._parse_account_name(tmp_buf)
# set account for using in world packet handlers
with AccountManager() as account_mgr:
self.temp_ref.account = account_mgr.get(
name=self.account_name).account
self.client_seed = tmp_buf.read(4)
self.client_hash = tmp_buf.read(20)
def process():
parser = argparse.ArgumentParser(prog='cmd')
commands = parser.add_subparsers(help='Available console commands')
# database
db_parser = commands.add_parser('db')
args = db_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'db':
if subcommand == 'create':
create_db()
Logger.success('All dbs was created')
elif subcommand == 'create_tables':
create_tables()
Logger.success('All required tables was created')
elif subcommand == 'drop':
drop_db()
Logger.warning('All db was dropped')
elif subcommand == 'recreate':
drop_db()
create_db()
create_tables()
Logger.notify('DB was successfully re-created')
elif subcommand == 'load_data':
load_world_data()
elif subcommand == 'recreate_with_load':
drop_db()
create_db()
create_tables()
Logger.notify('DB was successfully re-created')
load_world_data()
# accounts
account_parser = commands.add_parser('account')
account_parser.add_argument('-n', '--name')
account_parser.add_argument('-p', '--password')
args = account_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'account':
if subcommand == 'create':
with AccountManager() as account_mgr:
account_mgr.create(name=args[0].name,
password=args[0].password)
Logger.success('Account "{}" created successfully!'.format(
args[0].name))
# items
item_parser = commands.add_parser('item')
item_parser.add_argument('-d', '--display_id')
item_parser.add_argument('-i', '--item_type')
item_parser.add_argument('-e', '--entry')
args = item_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'item':
if subcommand == 'create':
with ItemManager() as item_mgr:
item_mgr.create(display_id=args[0].display_id,
item_type=args[0].item_type,
entry=int(args[0].entry)).save()
Logger.success('Item "{}" created successfully!'.format(
args[0].entry))
# spells
spell_parser = commands.add_parser('spell')
spell_parser.add_argument('-e', '--entry')
spell_parser.add_argument('-n', '--name')
spell_parser.add_argument('-c', '--cost')
spell_parser.add_argument('-s', '--school')
spell_parser.add_argument('-r', '--range')
args = spell_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'spell':
if subcommand == 'create':
SpellManager().create(entry=args[0].entry,
name=args[0].name,
cost=args[0].cost,
school=args[0].school,
range=args[0].range).save()
Logger.test('Spell "{}" ({}) created successfully!'.format(
args[0].name, args[0].entry))
# default spells
default_spell_parser = commands.add_parser('default_spell')
default_spell_parser.add_argument('-e', '--entry')
default_spell_parser.add_argument('-r', '--race')
default_spell_parser.add_argument('-c', '--char_class')
args = default_spell_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'default_spell':
if subcommand == 'create':
SpellManager().create_default_spell(
entry=args[0].entry,
race=args[0].race,
char_class=args[0].char_class).save()
Logger.test(
'Default spell "{}" ({}:{}) created successfully!'.format(
args[0].entry, args[0].race, args[0].char_class))
# skills
# skill_parser = commands.add_parser('skill')
# skill_parser.add_argument('-e', '--entry')
# skill_parser.add_argument('-n', '--name')
#
# args = skill_parser.parse_known_args()
# parser_name = args[1][0]
# subcommand = args[1].pop()
#
# if parser_name == 'skill':
# if subcommand == 'create':
# SkillManager().create(
# entry=args[0].entry,
# name=args[0].name
# ).save()
#
# Logger.test('Skill "{}" ({}) created successfully!'.format(args[0].name, args[0].entry))
# skills
skill_parser = commands.add_parser('skill')
skill_parser.add_argument('-e', '--entry')
skill_parser.add_argument('-n', '--name')
skill_parser.add_argument('--min')
skill_parser.add_argument('--max')
args = skill_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'skill':
if subcommand == 'create':
SkillManager().create(entry=args[0].entry,
name=args[0].name,
min=args[0].min,
max=args[0].max).save()
Logger.success('Skill "{}" ({}) created successfully!'.format(
args[0].name, args[0].entry))
# default skills
default_skill_parser = commands.add_parser('default_skill')
default_skill_parser.add_argument('-e', '--entry')
default_skill_parser.add_argument('-r', '--race')
default_skill_parser.add_argument('-c', '--char_class')
args = default_skill_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'default_skill':
if subcommand == 'create':
SkillManager().create_default_skill(
entry=args[0].entry,
race=args[0].race,
char_class=args[0].char_class).save()
Logger.success(
'Default skill "{}" ({}:{}) created successfully!'.format(
args[0].entry, args[0].race, args[0].char_class))
# regions
region_parser = commands.add_parser('region')
region_parser.add_argument('-i', '--identifier')
region_parser.add_argument('--y1')
region_parser.add_argument('--y2')
region_parser.add_argument('--x1')
region_parser.add_argument('--x2')
region_parser.add_argument('-c', '--continent_id')
# # arguments for default region
region_parser.add_argument('-r', '--race')
region_parser.add_argument('-m', '--map_id')
# # arguments for region unit # #
region_parser.add_argument('-u', '--unit_entry')
# # arguments for both default region and region unit
region_parser.add_argument('-x')
region_parser.add_argument('-y')
region_parser.add_argument('-z')
args = region_parser.parse_known_args()
parser_name = args[1][0]
subcommand = args[1].pop()
if parser_name == 'region':
if subcommand == 'create':
with RegionManager() as region_mgr:
region_mgr.create(
identifier=args[0].identifier,
y1=args[0].y1,
y2=args[0].y2,
x1=args[0].x1,
x2=args[0].x2,
continent_id=args[0].continent_id,
).save()
Logger.notify('Region "{}" created successfully!'.format(
args[0].identifier))
elif subcommand == 'add_default_location':
with RegionManager() as region_mgr:
region_mgr.create_default_location(
identifier=args[0].identifier,
x=args[0].x,
y=args[0].y,
z=args[0].z,
race=args[0].race,
map_id=args[0].map_id)
Logger.success(
'Default location ({}) for race "{}" successfully added'.
format(args[0].identifier, args[0].race))
elif subcommand == 'add_unit':
with UnitManager() as unit_mgr:
unit_mgr.new(entry=args[0].unit_entry,
identifier=args[0].identifier,
x=args[0].x,
y=args[0].y,
z=args[0].z).set_stats().save()
Logger.notify(
'Unit "{}" IN ({} - {} - {}) created successfully!'.format(
args[0].unit_entry, args[0].x, args[0].y, args[0].z))