class GetCmsMissionsRequest(SerializableMessage):
def __init__(self):
self.quest_type_id: ObjectID = None
self.hierarchies: list[str] = None
self.return_locked: bool = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.quest_type_id = ObjectID()
self.quest_type_id.deserialize(bit_stream)
self.hierarchies = []
for _ in range(bit_stream.read_int()):
self.hierarchies.append(bit_stream.read_str())
self.return_locked = bit_stream.read_bool()
def to_dict(self):
return {
'quest_type_id': self.quest_type_id.to_dict(),
'hierarchies': self.hierarchies,
'return_locked': self.return_locked,
}
class GetInventoryObjectsRequest(SerializableMessage):
def __init__(self):
self.container_id: ObjectID = None
self.item_category_ids: list[ObjectID] = None
self.player_item_ids: list[ObjectID] = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.container_id = ObjectID()
self.container_id.deserialize(bit_stream)
self.item_category_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.item_category_ids.append(item)
self.player_item_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.player_item_ids.append(item)
def to_dict(self):
return {
'container_id':
self.container_id.to_dict(),
'item_category_ids':
[item.to_dict() for item in self.item_category_ids],
'player_item_ids':
[item.to_dict() for item in self.player_item_ids],
}
class EnterBuildingRequest(SerializableMessage):
def __init__(self):
self.loc_id: ObjectID = None
self.building_id: ObjectID = None
self.pos: Position = None
self.orientation: Orientation = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.loc_id = ObjectID()
self.loc_id.deserialize(bit_stream)
self.building_id = ObjectID()
self.building_id.deserialize(bit_stream)
self.pos = Position()
self.pos.deserialize(bit_stream)
self.orientation = Orientation()
self.orientation.deserialize(bit_stream)
def to_dict(self):
return {
'loc_id':
self.loc_id.to_dict() if self.loc_id else None,
'building_id':
self.building_id.to_dict() if self.building_id else None,
'pos':
self.pos.to_dict() if self.pos else None,
'orientation':
self.orientation.to_dict() if self.orientation else None,
}
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.start = bit_stream.read_int()
self.max = bit_stream.read_int()
self.filter_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.filter_ids.append(item)
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.player_ids.append(item)
self.is_invite_or_accept = bit_stream.read_bool()
self.is_host = bit_stream.read_bool()
self.permanent = bit_stream.read_bool()
class RegisterPlayerRequest(SerializableMessage):
def __init__(self):
self.token: str = None
self.password: str = None
self.parent_email_address: str = None
self.birth_date: dt.datetime = None
self.gender: str = None
self.location_id: ObjectID = None
self.username: str = None
self.worldname: str = None
self.chat_allowed: bool = None
self.cnl: str = None
self.referred_by_worldname: str = None
self.login_type: int = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.token = bit_stream.read_str()
self.password = bit_stream.read_str()
self.parent_email_address = bit_stream.read_str()
self.birth_date = bit_stream.read_dt()
self.gender = bit_stream.read_str()
self.location_id = ObjectID()
self.location_id.deserialize(bit_stream)
self.username = bit_stream.read_str()
self.worldname = bit_stream.read_str()
self.chat_allowed = bit_stream.read_bool()
self.cnl = bit_stream.read_str()
self.referred_by_worldname = bit_stream.read_str()
self.login_type = bit_stream.read_int()
def to_dict(self):
return {
'token': self.token,
'password': self.password,
'parent_email_address': self.parent_email_address,
'birth_date': self.birth_date,
'gender': self.gender,
'location_id': self.location_id.to_dict(),
'username': self.username,
'worldname': self.worldname,
'chat_allowed': self.chat_allowed,
'cnl': self.cnl,
'referred_by_worldname': self.referred_by_worldname,
'login_type': self.login_type,
}
class GetNpcRelationshipsRequest(SerializableMessage):
def __init__(self):
self.zone_id: ObjectID = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.zone_id = ObjectID()
self.zone_id.deserialize(bit_stream)
def to_dict(self):
return {'zone_id': self.zone_id.to_dict()}
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.container_id = ObjectID()
self.container_id.deserialize(bit_stream)
self.item_category_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.item_category_ids.append(item)
self.player_item_ids = []
for _ in range(bit_stream.read_int()):
item = ObjectID()
item.deserialize(bit_stream)
self.player_item_ids.append(item)
class RegisterAvatarForRegistrationRequest(SerializableMessage):
def __init__(self):
self.player_id: ObjectID = None
self.secret_code: str = None
self.name: str = None
self.bio: str = None
self.avatar_id: ObjectID = None
self.given_inventory_ids: list[ObjectID] = None
self.given_item_slot_ids: list[ObjectID] = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
self.secret_code = bit_stream.read_str()
self.name = bit_stream.read_str()
self.bio = bit_stream.read_str()
self.avatar_id = ObjectID()
self.avatar_id.deserialize(bit_stream)
self.given_inventory_ids = []
for _ in range(bit_stream.read_int()):
object_id = ObjectID()
object_id.deserialize(bit_stream)
self.given_inventory_ids.append(object_id)
self.given_item_slot_ids = []
for _ in range(bit_stream.read_int()):
object_id = ObjectID()
object_id.deserialize(bit_stream)
self.given_item_slot_ids.append(object_id)
def to_dict(self):
return {
'player_id': self.player_id.to_dict(),
'secret_code': self.secret_code,
'name': self.name,
'bio': self.bio,
'avatar_id': self.avatar_id.to_dict(),
'given_inventory_ids': [item.to_dict() for item in self.given_inventory_ids],
'given_item_slot_ids': [item.to_dict() for item in self.given_item_slot_ids],
}
class LoginRequest(SerializableMessage):
def __init__(self):
self.login_id: str = None
self.password: str = None
self.site_pin: int = None
self.language_local_pair_id: ObjectID = None
self.user_queueing_token: str = None
self.client_environment: ClientEnvironment = None
self.token: str = None
self.login_type: int = None
self.cnl: str = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.login_id = bit_stream.read_str()
self.password = bit_stream.read_str()
self.site_pin = bit_stream.read_int()
self.language_local_pair_id = ObjectID()
self.language_local_pair_id.deserialize(bit_stream)
self.user_queueing_token = bit_stream.read_str()
self.client_environment = ClientEnvironment()
self.client_environment.deserialize(bit_stream)
self.token = bit_stream.read_str()
self.login_type = bit_stream.read_int()
self.cnl = bit_stream.read_str()
def to_dict(self):
return {
'login_id': self.login_id,
'password': self.password,
'site_pin': self.site_pin,
'language_local_pair_id': self.language_local_pair_id.to_dict(),
'user_queueing_token': self.user_queueing_token,
'client_environment': self.client_environment.to_dict(),
'token': self.token,
'login_type': self.login_type,
'cnl': self.cnl,
}
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
self.secret_code = bit_stream.read_str()
self.name = bit_stream.read_str()
self.bio = bit_stream.read_str()
self.avatar_id = ObjectID()
self.avatar_id.deserialize(bit_stream)
self.given_inventory_ids = []
for _ in range(bit_stream.read_int()):
object_id = ObjectID()
object_id.deserialize(bit_stream)
self.given_inventory_ids.append(object_id)
self.given_item_slot_ids = []
for _ in range(bit_stream.read_int()):
object_id = ObjectID()
object_id.deserialize(bit_stream)
self.given_item_slot_ids.append(object_id)
class GetOutfitsRequest(SerializableMessage):
def __init__(self):
self.player_avatar_id: ObjectID = None
self.player_id: ObjectID = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_avatar_id = ObjectID()
self.player_avatar_id.deserialize(bit_stream)
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
def to_dict(self):
return {
'player_avatar_id': self.player_avatar_id.to_dict(),
'player_id': self.player_id.to_dict(),
}
class GetHomeInvitationsRequest(SerializableMessage):
def __init__(self):
self.player_id: ObjectID = None
self.is_host: bool = None
self.is_status_pending: bool = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.player_id = ObjectID()
self.player_id.deserialize(bit_stream)
self.is_host = bit_stream.read_bool()
self.is_status_pending = bit_stream.read_bool()
def to_dict(self):
return {
'player_id': self.player_id.to_dict(),
'is_host': self.is_host,
'is_status_pending': self.is_status_pending,
}
class SyncLoginRequest(SerializableMessage):
def __init__(self):
self.uid: ObjectID = None
self.token: str = None
self.max_vis_size: int = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.uid = ObjectID()
self.uid.deserialize(bit_stream)
self.token = bit_stream.read_str()
self.max_vis_size = bit_stream.read_int()
def to_dict(self):
return {
'uid': self.uid.to_dict(),
'token': self.token,
'max_vis_size': self.max_vis_size,
}
class GetSiteFrameRequest(SerializableMessage):
def __init__(self):
self.type_value: int = None
self.lang_locale_pair_id: ObjectID = None
self.tier_id: ObjectID = None
self.birth_date: dt.datetime = None
self.registration_date: dt.datetime = None
self.preview_date: dt.datetime = None
self.is_preview_enabled: bool = None
def serialize(self, bit_stream: BitStream):
raise NotImplementedError
def deserialize(self, bit_stream: BitStream):
if not bit_stream.read_start():
return
self.type_value = bit_stream.read_int()
self.lang_locale_pair_id = ObjectID()
self.lang_locale_pair_id.deserialize(bit_stream)
self.tier_id = ObjectID()
self.tier_id.deserialize(bit_stream)
self.birth_date = bit_stream.read_dt()
self.registration_date = bit_stream.read_dt()
self.preview_date = bit_stream.read_dt()
self.is_preview_enabled = bit_stream.read_bool()
def to_dict(self):
return {
'type_value': self.type_value,
'lang_locale_pair_id': self.lang_locale_pair_id.to_dict(),
'tier_id': self.tier_id.to_dict(),
'birth_date': self.birth_date,
'registration_date': self.registration_date,
'preview_date': self.preview_date,
'is_preview_enabled': self.is_preview_enabled,
}