forked from Hay1tsme/artemis
12682 lines
425 KiB
Python
12682 lines
425 KiB
Python
from typing import Tuple, List, Optional, Dict
|
|
import struct
|
|
import logging
|
|
from datetime import datetime
|
|
from enum import IntEnum
|
|
|
|
BIGINT_OFF = 16
|
|
LONG_OFF = 8
|
|
INT_OFF = 4
|
|
SHORT_OFF = 2
|
|
BYTE_OFF = 1
|
|
|
|
DT_FMT = "%Y%m%d%H%M%S"
|
|
|
|
def fmt_dt(d: Optional[datetime] = None) -> str:
|
|
if d is None:
|
|
d = datetime.fromtimestamp(0)
|
|
return d.strftime(DT_FMT)
|
|
|
|
def prs_dt(s: Optional[str] = None) -> datetime:
|
|
if not s:
|
|
s = "19691231190000"
|
|
return datetime.strptime(s, DT_FMT)
|
|
|
|
def decode_num(data: bytes, offset: int, size: int) -> int:
|
|
try:
|
|
return int.from_bytes(data[offset:offset + size], 'big')
|
|
except:
|
|
logging.getLogger('sao').error(f"Failed to parse {data[offset:offset + size]} as BE number of width {size}")
|
|
return 0
|
|
|
|
def decode_byte(data: bytes, offset: int) -> int:
|
|
return decode_num(data, offset, BYTE_OFF)
|
|
|
|
def decode_short(data: bytes, offset: int) -> int:
|
|
return decode_num(data, offset, SHORT_OFF)
|
|
|
|
def decode_int(data: bytes, offset: int) -> int:
|
|
return decode_num(data, offset, INT_OFF)
|
|
|
|
def decode_long(data: bytes, offset: int) -> int:
|
|
return decode_num(data, offset, LONG_OFF)
|
|
|
|
def decode_bigint(data: bytes, offset: int) -> int:
|
|
return decode_num(data, offset, BIGINT_OFF)
|
|
|
|
def decode_str(data: bytes, offset: int) -> Tuple[str, int]:
|
|
try:
|
|
str_len = decode_int(data, offset)
|
|
num_bytes_decoded = INT_OFF + str_len
|
|
str_out = data[offset + INT_OFF:offset + num_bytes_decoded].decode("utf-16-le", errors="replace")
|
|
return (str_out, num_bytes_decoded)
|
|
except:
|
|
logging.getLogger('sao').error(f"Failed to parse {data[offset:]} as string!")
|
|
return ("", 0)
|
|
|
|
def decode_arr_num(data: bytes, offset:int, element_size: int) -> Tuple[List[int], int]:
|
|
size = 0
|
|
num_obj = decode_int(data, offset + size)
|
|
size += INT_OFF
|
|
|
|
ret: List[int] = []
|
|
for _ in range(num_obj):
|
|
ret.append(decode_num(data, offset + size, element_size))
|
|
size += element_size
|
|
|
|
return (ret, size)
|
|
|
|
def decode_arr_str(data: bytes, offset: int) -> Tuple[List[str], int]:
|
|
size = 0
|
|
num_obj = decode_int(data, offset + size)
|
|
size += INT_OFF
|
|
|
|
ret: List[str] = []
|
|
for _ in range(num_obj):
|
|
tmp = decode_str(data, offset + size)
|
|
ret.append(tmp[0])
|
|
size += tmp[1]
|
|
|
|
return (ret, size)
|
|
|
|
def decode_date_str(data: bytes, offset: int) -> Tuple[datetime, int]:
|
|
s, new_o = decode_str(data, offset)
|
|
return (prs_dt(s), new_o)
|
|
|
|
def decode_bool(data: bytes, offset: int) -> bool:
|
|
return bool(decode_byte(data, offset))
|
|
|
|
def encode_byte(data: int) -> bytes:
|
|
if data is None:
|
|
return b"\0"
|
|
try:
|
|
return struct.pack("!b", int(data))
|
|
except Exception as e:
|
|
logging.getLogger('sao').error(f"Failed to encode {data} as byte! - {e}")
|
|
return b"\0"
|
|
|
|
def encode_short(data: int) -> bytes:
|
|
if data is None:
|
|
return b"\0\0"
|
|
try:
|
|
return struct.pack("!h", int(data))
|
|
except Exception as e:
|
|
logging.getLogger('sao').error(f"Failed to encode {data} as short! - {e}")
|
|
return b"\0\0"
|
|
|
|
def encode_int(data: int) -> bytes:
|
|
if data is None:
|
|
return b"\0\0\0\0"
|
|
try:
|
|
return struct.pack("!i", int(data))
|
|
except Exception as e:
|
|
logging.getLogger('sao').error(f"Failed to encode {data} as int! - {e}")
|
|
return b"\0\0\0\0"
|
|
|
|
def encode_long(data: int) -> bytes:
|
|
if data is None:
|
|
return b"\0\0\0\0\0\0\0\0"
|
|
return struct.pack("!l", int(data))
|
|
|
|
def encode_bigint(data: int) -> bytes:
|
|
if data is None:
|
|
return b"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
|
return struct.pack("!q", int(data))
|
|
|
|
def encode_str(s: str) -> bytes:
|
|
if s is None:
|
|
return b"\0\0\0\0"
|
|
try:
|
|
str_bytes = str(s).encode("utf-16-le", errors="replace")
|
|
str_len_bytes = struct.pack("!I", len(str_bytes))
|
|
return str_len_bytes + str_bytes
|
|
except Exception as e:
|
|
logging.getLogger('sao').error(f"Failed to encode {s} as bytes! - {e}")
|
|
return b""
|
|
|
|
def encode_arr_num(data: List[int], element_size: int) -> bytes:
|
|
if data is None:
|
|
return b"\0\0\0\0"
|
|
ret = encode_int(len(data))
|
|
|
|
if element_size == BYTE_OFF:
|
|
for x in data:
|
|
ret += encode_byte(x)
|
|
elif element_size == SHORT_OFF:
|
|
for x in data:
|
|
ret += encode_short(x)
|
|
elif element_size == INT_OFF:
|
|
for x in data:
|
|
ret += encode_int(x)
|
|
elif element_size == LONG_OFF:
|
|
for x in data:
|
|
ret += encode_long(x)
|
|
elif element_size == BIGINT_OFF:
|
|
for x in data:
|
|
ret += encode_bigint(x)
|
|
else:
|
|
logging.getLogger('sao').error(f"Unknown element size {element_size}")
|
|
return b"\x00" * INT_OFF
|
|
|
|
return ret
|
|
|
|
def encode_bool(b: bool) -> bytes:
|
|
if b is None:
|
|
return b"\0"
|
|
return encode_byte(int(b))
|
|
|
|
def encode_date_str(d: datetime) -> bytes:
|
|
return encode_str(fmt_dt(d))
|
|
|
|
class PrintType(IntEnum):
|
|
NONE = 0
|
|
FromStorage = 1
|
|
FromGasha = 2
|
|
|
|
class AuthType(IntEnum):
|
|
UNKNOWN = 0
|
|
CARD = 1
|
|
MOBLE = 2
|
|
|
|
class ActTypeConsumeTicket(IntEnum):
|
|
QuestEpisodeBeginner = 1
|
|
QuestEpisode = 2
|
|
QuestTrialTowerBeginner = 3
|
|
QuestTrialTower = 4
|
|
QuestPvEBeginner = 5
|
|
QuestPvE = 6
|
|
QuestContinue = 7
|
|
QuesRarityUp = 8
|
|
QuestEpisodeBoost = 9
|
|
QuestTrialTowerBoost = 10
|
|
QuestPvEBoost = 11
|
|
CustomModeExtend = 21
|
|
CustomModeRetry = 22
|
|
YuiMedalShop = 31
|
|
|
|
class ActTypeChangeParty(IntEnum):
|
|
MANUAL = 1
|
|
AUTO = 2
|
|
|
|
class ActTypeConsumeCredit(IntEnum):
|
|
PurchaseTicketA1 = 1
|
|
PurchaseTicketA2 = 2
|
|
PurchaseTicketA6 = 3
|
|
PurchaseTicketB1 = 4
|
|
PurchaseTicketB2 = 5
|
|
PurchaseTicketB7 = 6
|
|
PurchaseTicketC1 = 7
|
|
PurchaseTicketC3 = 8
|
|
PurchaseTicketC8 = 9
|
|
PurchaseTicketD1 = 10
|
|
PurchaseTicketD2 = 11
|
|
PurchaseTicketD6 = 12
|
|
PurchaseTicketE1 = 13
|
|
PurchaseTicketE3 = 14
|
|
PurchaseTicketE8 = 15
|
|
PurchaseTicketF1 = 16
|
|
PurchaseTicketF2 = 17
|
|
PurchaseTicketF6 = 18
|
|
QuestContinue = 21
|
|
QuestRarityUp = 22
|
|
GashaSatelite = 31
|
|
GashaSateliteAdd1 = 32
|
|
GashaSateliteAdd2 = 33
|
|
GashaTerminal = 41
|
|
GashaTerminalAdd1 = 42
|
|
GashaTerminalAdd2 = 43
|
|
ResourceDischarge = 44
|
|
ResourceHolo = 45
|
|
ProfileCardDischarge = 46
|
|
ProfileCardHolo = 47
|
|
|
|
class ProtocolErrorNum(IntEnum): # header error_num field
|
|
SUCCESS = 0
|
|
|
|
ALREADY_LOGIN_DIFF = 1301
|
|
ALREADY_LOGIN_SAME = 1302
|
|
INVALID_AUTH_TYPE = 1303
|
|
INVALID_CABINET_TYPE = 1304
|
|
AMID_SERVER_CONNECT_ERROR = 1305
|
|
AMID_INFO_REQUEST_ERROR = 1306
|
|
NOT_EXIST_PLAY_DATA = 1307
|
|
HAVE_NEVER_PLAYED_SATELLITE = 1308
|
|
|
|
RESOURCE_CARD_ERR1 = 4831 # ScanQRQuestProfileCard
|
|
RESOURCE_CARD_NOT_EXIST = 4832
|
|
RESOURCE_CARD_ERR3 = 4833 # ScanQRQuestResourceCard / ScanQRShopResourceCard
|
|
RESOURCE_CARD_ERR6 = 4836 # ScanQRQuestResourceCard / ScanQRShopResourceCard
|
|
RESOURCE_CARD_ERR7 = 4837 # ScanQRQuestResourceCard / ScanQRShopResourceCard
|
|
RESOURCE_CARD_ERR8 = 4838 # ScanQRShopResourceCard
|
|
RESOURCE_CARD_ERR9 = 4839 # ScanQRQuestProfileCard
|
|
|
|
CREDIT_GASHA_ERROR = 7111
|
|
|
|
PURCHASE_ERROR = 7711
|
|
|
|
PAYING_PLAY_END_ERROR = 9120
|
|
|
|
CODE_ANALYSIS_API_NOT_RESPONSE = 9201
|
|
CODE_ANALYSIS_API_INIQUITY_SERIAL_CODE = 9202
|
|
CODE_USE_API_USED_SERIAL_CODE = 9203
|
|
CODE_USE_API_NOT_RESPONSE = 9206
|
|
CODE_USE_API_NG = 9207
|
|
CODE_USE_API_LOCK = 9208
|
|
CODE_USE_API_MAINTENANCE = 9209
|
|
CODE_ANALYSIS_API_NOT_MASTER_DATA = 9210
|
|
CODE_ANALYSIS_API_EXPIRED_SERIAL_CODE = 9211
|
|
|
|
class ProtocolResult(IntEnum): # result field, if used
|
|
NONE = -1
|
|
FAILED = 0
|
|
SUCCESS = 1
|
|
PARAM_ERROR = 2
|
|
MAINTENANCE = 3
|
|
CONNECT_ERROR = 99
|
|
|
|
class BaseHelper:
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self._sz = 0
|
|
|
|
@classmethod
|
|
def from_args(cls) -> "BaseHelper":
|
|
return cls(b"", 0)
|
|
|
|
def get_size(self) -> int:
|
|
return self._sz
|
|
|
|
def make(self) -> bytes:
|
|
return b""
|
|
|
|
def decode_arr_cls(data: bytes, offset: int, cls: BaseHelper):
|
|
size = 0
|
|
num_cls = decode_int(data, offset + size)
|
|
size += INT_OFF
|
|
cls_type = type(cls)
|
|
|
|
ret: List[cls_type] = [] # type: ignore
|
|
for _ in range(num_cls):
|
|
tmp = cls(data, offset + size)
|
|
size += tmp.get_size()
|
|
ret.append(tmp)
|
|
|
|
return (ret, size)
|
|
|
|
def encode_arr_cls(data: List[BaseHelper]) -> bytes:
|
|
ret = encode_int(len(data))
|
|
|
|
for x in data:
|
|
ret += x.make()
|
|
|
|
return ret
|
|
|
|
class MaterialCommonRewardUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.common_reward_type = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
user_common_reward_id = decode_str(data, offset + self._sz)
|
|
self.user_common_reward_id = user_common_reward_id[0]
|
|
self._sz += user_common_reward_id[1]
|
|
|
|
class QuestScenePlayEndUnanalyzedLogRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unanalyzed_log_grade_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_data, new_off = decode_arr_cls(data, off, CommonRewardData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, grade: int, reward: Dict) -> "QuestScenePlayEndUnanalyzedLogRewardData":
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.unanalyzed_log_grade_id = grade
|
|
ret.common_reward_data = [CommonRewardData.from_args(reward.get('CommonRewardType'), reward.get('CommonRewardId'), reward.get('CommonRewardNum'))]
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unanalyzed_log_grade_id) \
|
|
+ encode_arr_cls(self.common_reward_data)
|
|
|
|
class PartyTeamData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_party_team_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.arrangement_num = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.user_hero_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.main_weapon_user_equipment_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_equipment_user_equipment_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.skill_slot1_skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_slot2_skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_slot3_skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_slot4_skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_slot5_skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, party_team_id: str, arr_num: int, data: Dict) -> "PartyTeamData":
|
|
ret = cls(b"\x00" * 37, 0)
|
|
ret.user_party_team_id = party_team_id
|
|
ret.arrangement_num = arr_num
|
|
ret.user_hero_log_id = data['id']
|
|
ret.main_weapon_user_equipment_id = data['main_weapon']
|
|
ret.sub_equipment_user_equipment_id = data['sub_equipment']
|
|
ret.skill_slot1_skill_id = data['skill_slot1_skill_id']
|
|
ret.skill_slot2_skill_id = data['skill_slot2_skill_id']
|
|
ret.skill_slot3_skill_id = data['skill_slot3_skill_id']
|
|
ret.skill_slot4_skill_id = data['skill_slot4_skill_id']
|
|
ret.skill_slot5_skill_id = data['skill_slot5_skill_id']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_party_team_id) \
|
|
+ encode_byte(self.arrangement_num) \
|
|
+ encode_str(self.user_hero_log_id) \
|
|
+ encode_str(self.main_weapon_user_equipment_id) \
|
|
+ encode_str(self.sub_equipment_user_equipment_id) \
|
|
+ encode_int(self.skill_slot1_skill_id) \
|
|
+ encode_int(self.skill_slot2_skill_id) \
|
|
+ encode_int(self.skill_slot3_skill_id) \
|
|
+ encode_int(self.skill_slot4_skill_id) \
|
|
+ encode_int(self.skill_slot5_skill_id)
|
|
|
|
class CommonRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.common_reward_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, reward_type: int, reward_id: int, reward_num: int) -> "CommonRewardData":
|
|
ret = cls(b"\x00" * 10, 0)
|
|
ret.common_reward_type = reward_type
|
|
ret.common_reward_id = reward_id
|
|
ret.common_reward_num = reward_num
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num)
|
|
|
|
class ReadProfileCardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.profile_card_code, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.nick_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rank_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.setting_title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_log_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_equipment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_enhancement_value = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.main_weapon_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.main_weapon_property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_equipment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_enhancement_value = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equipment_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equipment_property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.holographic_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, user_profile: Dict, hero_data: Dict) -> "ReadProfileCardData":
|
|
ret = cls(b"\x00" * 185, 0)
|
|
# TODO: real data
|
|
ret.profile_card_code = ""
|
|
ret.nick_name = ""
|
|
ret.rank_num = 0
|
|
ret.setting_title_id = 0
|
|
ret.skill_id = 0
|
|
ret.hero_log_hero_log_id = 0
|
|
ret.hero_log_log_level = 0
|
|
ret.hero_log_awakening_stage = 0
|
|
ret.hero_log_property1_property_id = 0
|
|
ret.hero_log_property1_value1 = 0
|
|
ret.hero_log_property1_value2 = 0
|
|
ret.hero_log_property2_property_id = 0
|
|
ret.hero_log_property2_value1 = 0
|
|
ret.hero_log_property2_value2 = 0
|
|
ret.hero_log_property3_property_id = 0
|
|
ret.hero_log_property3_value1 = 0
|
|
ret.hero_log_property3_value2 = 0
|
|
ret.hero_log_property4_property_id = 0
|
|
ret.hero_log_property4_value1 = 0
|
|
ret.hero_log_property4_value2 = 0
|
|
ret.main_weapon_equipment_id = 0
|
|
ret.main_weapon_enhancement_value = 0
|
|
ret.main_weapon_awakening_stage = 0
|
|
ret.main_weapon_property1_property_id = 0
|
|
ret.main_weapon_property1_value1 = 0
|
|
ret.main_weapon_property1_value2 = 0
|
|
ret.main_weapon_property2_property_id = 0
|
|
ret.main_weapon_property2_value1 = 0
|
|
ret.main_weapon_property2_value2 = 0
|
|
ret.main_weapon_property3_property_id = 0
|
|
ret.main_weapon_property3_value1 = 0
|
|
ret.main_weapon_property3_value2 = 0
|
|
ret.main_weapon_property4_property_id = 0
|
|
ret.main_weapon_property4_value1 = 0
|
|
ret.main_weapon_property4_value2 = 0
|
|
ret.sub_equipment_equipment_id = 0
|
|
ret.sub_equipment_enhancement_value = 0
|
|
ret.sub_equipment_awakening_stage = 0
|
|
ret.sub_equipment_property1_property_id = 0
|
|
ret.sub_equipment_property1_value1 = 0
|
|
ret.sub_equipment_property1_value2 = 0
|
|
ret.sub_equipment_property2_property_id = 0
|
|
ret.sub_equipment_property2_value1 = 0
|
|
ret.sub_equipment_property2_value2 = 0
|
|
ret.sub_equipment_property3_property_id = 0
|
|
ret.sub_equipment_property3_value1 = 0
|
|
ret.sub_equipment_property3_value2 = 0
|
|
ret.sub_equipment_property4_property_id = 0
|
|
ret.sub_equipment_property4_value1 = 0
|
|
ret.sub_equipment_property4_value2 = 0
|
|
ret.holographic_flag = 0
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.profile_card_code) \
|
|
+ encode_str(self.nick_name) \
|
|
+ encode_short(self.rank_num) \
|
|
+ encode_int(self.setting_title_id) \
|
|
+ encode_short(self.skill_id) \
|
|
+ encode_int(self.hero_log_hero_log_id) \
|
|
+ encode_short(self.hero_log_log_level) \
|
|
+ encode_short(self.hero_log_awakening_stage) \
|
|
+ encode_int(self.hero_log_property1_property_id) \
|
|
+ encode_int(self.hero_log_property1_value1) \
|
|
+ encode_int(self.hero_log_property1_value2) \
|
|
+ encode_int(self.hero_log_property2_property_id) \
|
|
+ encode_int(self.hero_log_property2_value1) \
|
|
+ encode_int(self.hero_log_property2_value2) \
|
|
+ encode_int(self.hero_log_property3_property_id) \
|
|
+ encode_int(self.hero_log_property3_value1) \
|
|
+ encode_int(self.hero_log_property3_value2) \
|
|
+ encode_int(self.hero_log_property4_property_id) \
|
|
+ encode_int(self.hero_log_property4_value1) \
|
|
+ encode_int(self.hero_log_property4_value2) \
|
|
+ encode_int(self.main_weapon_equipment_id) \
|
|
+ encode_short(self.main_weapon_enhancement_value) \
|
|
+ encode_short(self.main_weapon_awakening_stage) \
|
|
+ encode_int(self.main_weapon_property1_property_id) \
|
|
+ encode_int(self.main_weapon_property1_value1) \
|
|
+ encode_int(self.main_weapon_property1_value2) \
|
|
+ encode_int(self.main_weapon_property2_property_id) \
|
|
+ encode_int(self.main_weapon_property2_value1) \
|
|
+ encode_int(self.main_weapon_property2_value2) \
|
|
+ encode_int(self.main_weapon_property3_property_id) \
|
|
+ encode_int(self.main_weapon_property3_value1) \
|
|
+ encode_int(self.main_weapon_property3_value2) \
|
|
+ encode_int(self.main_weapon_property4_property_id) \
|
|
+ encode_int(self.main_weapon_property4_value1) \
|
|
+ encode_int(self.main_weapon_property4_value2) \
|
|
+ encode_int(self.sub_equipment_equipment_id) \
|
|
+ encode_short(self.sub_equipment_enhancement_value) \
|
|
+ encode_short(self.sub_equipment_awakening_stage) \
|
|
+ encode_int(self.sub_equipment_property1_property_id) \
|
|
+ encode_int(self.sub_equipment_property1_value1) \
|
|
+ encode_int(self.sub_equipment_property1_value2) \
|
|
+ encode_int(self.sub_equipment_property2_property_id) \
|
|
+ encode_int(self.sub_equipment_property2_value1) \
|
|
+ encode_int(self.sub_equipment_property2_value2) \
|
|
+ encode_int(self.sub_equipment_property3_property_id) \
|
|
+ encode_int(self.sub_equipment_property3_value1) \
|
|
+ encode_int(self.sub_equipment_property3_value2) \
|
|
+ encode_int(self.sub_equipment_property4_property_id) \
|
|
+ encode_int(self.sub_equipment_property4_value1) \
|
|
+ encode_int(self.sub_equipment_property4_value2) \
|
|
+ encode_byte(self.holographic_flag)
|
|
|
|
class QuestSceneBestScoreUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.clear_time = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.combo_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.total_damage, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.concurrent_destroying_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSceneBestScoreUserData":
|
|
ret = cls(b"\x00" * 14, 0)
|
|
ret.clear_time = data['clear_time']
|
|
ret.combo_num = data['combo_num']
|
|
ret.total_damage = data['total_damage']
|
|
ret.concurrent_destroying_num = data['concurrent_destroying_num']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.clear_time) \
|
|
+ encode_int(self.combo_num) \
|
|
+ encode_str(self.total_damage) \
|
|
+ encode_short(self.concurrent_destroying_num)
|
|
|
|
class QuestSceneExBonusUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ex_bonus_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.achievement_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, table_id: int = 0, ach_flag: bool = False) -> "QuestSceneExBonusUserData":
|
|
ret = cls(b"\x00" * 5, 0)
|
|
ret.ex_bonus_table_id = table_id
|
|
ret.achievement_flag = ach_flag
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ex_bonus_table_id) \
|
|
+ encode_byte(self.achievement_flag)
|
|
|
|
class QuestSceneUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.quest_scene_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.clear_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.quest_scene_best_score_user_data: List[QuestSceneBestScoreUserData] = []
|
|
self.quest_scene_best_score_user_data, new_off = decode_arr_cls(data, off, QuestSceneBestScoreUserData)
|
|
off += new_off
|
|
|
|
self.quest_scene_ex_bonus_user_data_list: List[QuestSceneExBonusUserData] = []
|
|
self.quest_scene_ex_bonus_user_data_list, new_off = decode_arr_cls(data, off, QuestSceneExBonusUserData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSceneUserData":
|
|
ret = cls(b"\x00" * 12, 0)
|
|
ret.quest_type = data['quest_type']
|
|
ret.quest_scene_id = data['quest_scene_id']
|
|
ret.clear_flag = data['quest_clear_flag']
|
|
ret.quest_scene_best_score_user_data = [QuestSceneBestScoreUserData.from_args(data)]
|
|
ret.quest_scene_ex_bonus_user_data_list = [] # TODO
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.quest_type) \
|
|
+ encode_short(self.quest_scene_id) \
|
|
+ encode_byte(self.clear_flag) \
|
|
+ encode_arr_cls(self.quest_scene_best_score_user_data) \
|
|
+ encode_arr_cls(self.quest_scene_ex_bonus_user_data_list)
|
|
|
|
class QuestScenePlayStartAppearancePlayerTraceData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_quest_scene_player_trace_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.nick_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, sesh_id:int, nickname: str) -> "QuestScenePlayStartAppearancePlayerTraceData":
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.user_quest_scene_player_trace_id = str(sesh_id)
|
|
ret.nick_name = nickname
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_quest_scene_player_trace_id) \
|
|
+ encode_str(self.nick_name)
|
|
|
|
class QuestScenePlayStartResponseData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.appearance_player_trace_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayStartAppearancePlayerTraceData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, sesh_id: int, nickname: str) -> "QuestScenePlayStartResponseData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.appearance_player_trace_data_list = [QuestScenePlayStartAppearancePlayerTraceData.from_args(sesh_id, nickname)]
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_arr_cls(self.appearance_player_trace_data_list)
|
|
|
|
class QuestScenePlayStartRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_party_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.appoint_leader_resource_card_code, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.use_profile_card_code, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_drop_boost_apply_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayStartRequestData":
|
|
ret = cls(b"\x00" * 13, 0)
|
|
ret.user_party_id = data['UserPartyId']
|
|
ret.appoint_leader_resource_card_code = data['AppointLeaderResourceCardCode']
|
|
ret.use_profile_card_code = data['UseProfileCardCode']
|
|
ret.quest_drop_boost_apply_flag = data['QuestDropBoostApplyFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_party_id) \
|
|
+ encode_str(self.appoint_leader_resource_card_code) \
|
|
+ encode_str(self.use_profile_card_code) \
|
|
+ encode_byte(self.quest_drop_boost_apply_flag)
|
|
|
|
class QuestSceneMultiPlayStartEntryUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.store_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.host_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSceneMultiPlayStartEntryUserData":
|
|
ret = cls(b"\x00" * 9, 0)
|
|
ret.store_id = data['StoreId']
|
|
ret.user_id = data['UserId']
|
|
ret.host_flag = data['HostFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.store_id) \
|
|
+ encode_str(self.user_id) \
|
|
+ encode_byte(self.host_flag)
|
|
|
|
class QuestSceneMultiPlayStartRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.room_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.matching_mode = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.entry_user_data_list: List[QuestSceneMultiPlayStartEntryUserData] = []
|
|
self.entry_user_data_list, new_off = decode_arr_cls(data, off, QuestSceneMultiPlayStartEntryUserData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSceneMultiPlayStartRequestData":
|
|
ret = cls(b"\x00" * 9, 0)
|
|
ret.room_id = data['RoomId']
|
|
ret.matching_mode = data['MatchingMode']
|
|
ret.entry_user_data_list = []
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.room_id) \
|
|
+ encode_byte(self.matching_mode) \
|
|
+ encode_arr_cls(self.entry_user_data_list)
|
|
|
|
class QuestSceneMultiPlayStartResponseData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.dummy_1 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.dummy_2 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.dummy_3 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls) -> "QuestSceneMultiPlayStartResponseData":
|
|
ret = cls(b"\x00" * 3, 0)
|
|
ret.dummy_1 = 0
|
|
ret.dummy_2 = 0
|
|
ret.dummy_3 = 0
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.dummy_1) \
|
|
+ encode_byte(self.dummy_2) \
|
|
+ encode_byte(self.dummy_3)
|
|
|
|
class QuestSceneMultiPlayEndResponseData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.dummy_1 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.dummy_2 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.dummy_3 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls) -> "QuestSceneMultiPlayEndResponseData":
|
|
ret = cls(b"\x00" * 3, 0)
|
|
ret.dummy_1 = 0
|
|
ret.dummy_2 = 0
|
|
ret.dummy_3 = 0
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.dummy_1) \
|
|
+ encode_byte(self.dummy_2) \
|
|
+ encode_byte(self.dummy_3)
|
|
|
|
class QuestScenePlayEndBaseGetData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.get_hero_log_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_col = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndBaseGetData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.get_hero_log_exp = data['GetHeroLogExp']
|
|
ret.get_col = data['GetCol']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.get_hero_log_exp) \
|
|
+ encode_int(self.get_col)
|
|
|
|
class QuestScenePlayEndDiscoveryEnemyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.enemy_kind_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.destroy_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndDiscoveryEnemyData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.enemy_kind_id = data['EnemyKindId']
|
|
ret.destroy_num = data['DestroyNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.enemy_kind_id) \
|
|
+ encode_short(self.destroy_num)
|
|
|
|
class QuestScenePlayEndGetPlayerTraceData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_quest_scene_player_trace_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndGetPlayerTraceData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.user_quest_scene_player_trace_id = data['UserQuestScenePlayerTraceId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_quest_scene_player_trace_id)
|
|
|
|
class QuestScenePlayEndGetRareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_rare_drop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndGetRareDropData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_rare_drop_id = data['QuestRareDropId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_rare_drop_id)
|
|
|
|
class QuestScenePlayEndGetSpecialRareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_special_rare_drop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndGetSpecialRareDropData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_special_rare_drop_id = data['QuestSpecialRareDropId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_special_rare_drop_id)
|
|
|
|
class QuestScenePlayEndGetUnanalyzedLogTmpRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unanalyzed_log_grade_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndGetUnanalyzedLogTmpRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.unanalyzed_log_grade_id = data['UnanalyzedLogGradeId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unanalyzed_log_grade_id)
|
|
|
|
class QuestScenePlayEndScoreData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.clear_time = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.combo_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.total_damage, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.concurrent_destroying_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.reaching_skill_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.ko_chara_num = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.acceleration_invocation_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.boss_destroying_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.synchro_skill_used_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.used_friend_skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.friend_skill_used_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.continue_cnt = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_loss_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndScoreData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.clear_time = data['ClearTime']
|
|
ret.combo_num = data['ComboNum']
|
|
ret.total_damage = data['TotalDamage']
|
|
ret.concurrent_destroying_num = data['ConcurrentDestroyingNum']
|
|
ret.reaching_skill_level = data['ReachingSkillLevel']
|
|
ret.ko_chara_num = data['KoCharaNum']
|
|
ret.acceleration_invocation_num = data['AccelerationInvocationNum']
|
|
ret.boss_destroying_num = data['BossDestroyingNum']
|
|
ret.synchro_skill_used_flag = data['SynchroSkillUsedFlag']
|
|
ret.used_friend_skill_id = data['UsedFriendSkillId']
|
|
ret.friend_skill_used_flag = data['FriendSkillUsedFlag']
|
|
ret.continue_cnt = data['ContinueCnt']
|
|
ret.total_loss_num = data['TotalLossNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.clear_time) \
|
|
+ encode_int(self.combo_num) \
|
|
+ encode_str(self.total_damage) \
|
|
+ encode_short(self.concurrent_destroying_num) \
|
|
+ encode_short(self.reaching_skill_level) \
|
|
+ encode_byte(self.ko_chara_num) \
|
|
+ encode_short(self.acceleration_invocation_num) \
|
|
+ encode_short(self.boss_destroying_num) \
|
|
+ encode_byte(self.synchro_skill_used_flag) \
|
|
+ encode_int(self.used_friend_skill_id) \
|
|
+ encode_byte(self.friend_skill_used_flag) \
|
|
+ encode_short(self.continue_cnt) \
|
|
+ encode_short(self.total_loss_num)
|
|
|
|
class QuestScenePlayEndMissionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.clear_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.mission_difficulty_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndMissionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.mission_id = data['MissionId']
|
|
ret.clear_flag = data['ClearFlag']
|
|
ret.mission_difficulty_id = data['MissionDifficultyId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.mission_id) \
|
|
+ encode_byte(self.clear_flag) \
|
|
+ encode_short(self.mission_difficulty_id)
|
|
|
|
class QuestScenePlayEndDestroyBossData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.boss_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.enemy_kind_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.destroy_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndDestroyBossData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.boss_type = data['BossType']
|
|
ret.enemy_kind_id = data['EnemyKindId']
|
|
ret.destroy_num = data['DestroyNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.boss_type) \
|
|
+ encode_int(self.enemy_kind_id) \
|
|
+ encode_short(self.destroy_num)
|
|
|
|
class QuestScenePlayEndGetEventItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.event_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndGetEventItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.event_item_id = data['EventItemId']
|
|
ret.get_num = data['GetNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.event_item_id) \
|
|
+ encode_short(self.get_num)
|
|
|
|
class QuestTreasureHuntPlayEndResponseData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.get_event_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.total_event_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, get_pt: int = 0, total_pt: int = 0) -> "QuestTreasureHuntPlayEndResponseData":
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.get_event_point = get_pt
|
|
ret.total_event_point = total_pt
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.get_event_point) \
|
|
+ encode_int(self.total_event_point)
|
|
|
|
class QuestTrialTowerPlayEndUpdatedNotificationData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.store_best_score_clear_time_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.store_best_score_combo_num_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.store_best_score_total_damage_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.store_best_score_concurrent_destroying_num_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.store_reaching_trial_tower_rank = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, shop_best_time: bool = False, shop_best_combo: bool = False, shop_best_damage: bool = False, shop_best_concurrent: bool = False, shop_tower_rank: int = 0) -> "QuestTrialTowerPlayEndUpdatedNotificationData":
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.store_best_score_clear_time_flag = shop_best_time
|
|
ret.store_best_score_combo_num_flag = shop_best_combo
|
|
ret.store_best_score_total_damage_flag = shop_best_damage
|
|
ret.store_best_score_concurrent_destroying_num_flag = shop_best_concurrent
|
|
ret.store_reaching_trial_tower_rank = shop_tower_rank
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.store_best_score_clear_time_flag) \
|
|
+ encode_byte(self.store_best_score_combo_num_flag) \
|
|
+ encode_byte(self.store_best_score_total_damage_flag) \
|
|
+ encode_byte(self.store_best_score_concurrent_destroying_num_flag) \
|
|
+ encode_int(self.store_reaching_trial_tower_rank)
|
|
|
|
class CommonRewardUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.common_reward_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.user_common_reward_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CommonRewardUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.user_common_reward_id = data['UserCommonRewardId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.common_reward_type) \
|
|
+ encode_str(self.user_common_reward_id)
|
|
|
|
class QuestScenePlayEndResponseData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.rarity_up_occurrence_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.adventure_ex_area_occurrences_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.ex_bonus_data_list: List[QuestScenePlayEndExBonusData] = []
|
|
self.ex_bonus_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndExBonusData)
|
|
off += new_off
|
|
|
|
self.play_end_player_trace_reward_data_list: List[QuestScenePlayEndPlayerTraceRewardData] = []
|
|
self.play_end_player_trace_reward_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndPlayerTraceRewardData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, rarity_up_flag: bool = False, adventure_ex_area_flg: bool = False, ex_tables: List = []) -> "QuestScenePlayEndResponseData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.rarity_up_occurrence_flag = rarity_up_flag
|
|
ret.adventure_ex_area_occurrences_flag = adventure_ex_area_flg
|
|
for x in ex_tables:
|
|
ret.ex_bonus_data_list.append(QuestScenePlayEndExBonusData.from_args(x['table'], x['ach_status']))
|
|
ret.play_end_player_trace_reward_data_list = []
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.rarity_up_occurrence_flag) \
|
|
+ encode_byte(self.adventure_ex_area_occurrences_flag) \
|
|
+ encode_arr_cls(self.ex_bonus_data_list) \
|
|
+ encode_arr_cls(self.play_end_player_trace_reward_data_list)
|
|
|
|
class QuestScenePlayEndExBonusData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ex_bonus_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.achievement_status = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, table_id: int, ach_status: int) -> "QuestScenePlayEndExBonusData":
|
|
ret = cls(b"\x00" * 5, 0)
|
|
ret.ex_bonus_table_id = table_id
|
|
ret.achievement_status = ach_status
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ex_bonus_table_id) \
|
|
+ encode_byte(self.achievement_status)
|
|
|
|
class QuestScenePlayEndPlayerTraceRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.common_reward_data: List[CommonRewardData]
|
|
self.common_reward_data, new_off = decode_arr_cls(data, off, CommonRewardData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, reward_data: Dict) -> "QuestScenePlayEndPlayerTraceRewardData":
|
|
ret = cls(b"\x00" * 4, 0)
|
|
ret.common_reward_data.append(CommonRewardData.from_args(reward_data['CommonRewardType'], reward_data['CommonRewardId'], reward_data['CommonRewardNum']))
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_arr_cls(self.common_reward_data)
|
|
|
|
class QuestScenePlayEndRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.play_result_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.base_get_data: List[QuestScenePlayEndBaseGetData] = []
|
|
self.base_get_data, new_off = decode_arr_cls(data, off, QuestScenePlayEndBaseGetData)
|
|
off += new_off
|
|
|
|
self.get_player_trace_data_list: List[QuestScenePlayEndGetPlayerTraceData] = []
|
|
self.get_player_trace_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndGetPlayerTraceData)
|
|
off += new_off
|
|
|
|
self.get_rare_drop_data_list: List[QuestScenePlayEndGetRareDropData] = []
|
|
self.get_rare_drop_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndGetRareDropData)
|
|
off += new_off
|
|
|
|
self.get_special_rare_drop_data_list: List[QuestScenePlayEndGetSpecialRareDropData] = []
|
|
self.get_special_rare_drop_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndGetSpecialRareDropData)
|
|
off += new_off
|
|
|
|
self.get_unanalyzed_log_tmp_reward_data_list: List[QuestScenePlayEndGetUnanalyzedLogTmpRewardData] = []
|
|
self.get_unanalyzed_log_tmp_reward_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndGetUnanalyzedLogTmpRewardData)
|
|
off += new_off
|
|
|
|
self.get_event_item_data_list: List[QuestScenePlayEndGetEventItemData] = []
|
|
self.get_event_item_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndGetEventItemData)
|
|
off += new_off
|
|
|
|
self.discovery_enemy_data_list: List[QuestScenePlayEndDiscoveryEnemyData] = []
|
|
self.discovery_enemy_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndDiscoveryEnemyData)
|
|
off += new_off
|
|
|
|
self.destroy_boss_data_list: List[QuestScenePlayEndDestroyBossData] = []
|
|
self.destroy_boss_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndDestroyBossData)
|
|
off += new_off
|
|
|
|
self.mission_data_list: List[QuestScenePlayEndMissionData] = []
|
|
self.mission_data_list, new_off = decode_arr_cls(data, off, QuestScenePlayEndMissionData)
|
|
off += new_off
|
|
|
|
self.score_data: List[QuestScenePlayEndScoreData] = []
|
|
self.score_data, new_off = decode_arr_cls(data, off, QuestScenePlayEndScoreData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestScenePlayEndRequestData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.play_result_flag = data['PlayResultFlag']
|
|
ret.base_get_data = []
|
|
ret.get_player_trace_data_list = []
|
|
ret.get_rare_drop_data_list = []
|
|
ret.get_special_rare_drop_data_list = []
|
|
ret.get_unanalyzed_log_tmp_reward_data_list = []
|
|
ret.get_event_item_data_list = []
|
|
ret.discovery_enemy_data_list = []
|
|
ret.destroy_boss_data_list = []
|
|
ret.mission_data_list = []
|
|
ret.score_data = []
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.play_result_flag) \
|
|
+ encode_arr_cls(self.base_get_data) \
|
|
+ encode_arr_cls(self.get_player_trace_data_list) \
|
|
+ encode_arr_cls(self.get_rare_drop_data_list) \
|
|
+ encode_arr_cls(self.get_special_rare_drop_data_list) \
|
|
+ encode_arr_cls(self.get_unanalyzed_log_tmp_reward_data_list) \
|
|
+ encode_arr_cls(self.get_event_item_data_list) \
|
|
+ encode_arr_cls(self.discovery_enemy_data_list) \
|
|
+ encode_arr_cls(self.destroy_boss_data_list) \
|
|
+ encode_arr_cls(self.mission_data_list) \
|
|
+ encode_arr_cls(self.score_data)
|
|
|
|
class QuestSceneMultiPlayEndRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.dummy_1 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.dummy_2 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.dummy_3 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls) -> "QuestSceneMultiPlayEndRequestData":
|
|
ret = cls(b"\x00" * 3, 0)
|
|
ret.dummy_1 = 0
|
|
ret.dummy_2 = 0
|
|
ret.dummy_3 = 0
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.dummy_1) \
|
|
+ encode_byte(self.dummy_2) \
|
|
+ encode_byte(self.dummy_3)
|
|
|
|
class ChatSideStoryUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chat_side_story_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.played_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ChatSideStoryUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chat_side_story_id = data['ChatSideStoryId']
|
|
ret.played_flag = data['PlayedFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.chat_side_story_id) \
|
|
+ encode_byte(self.played_flag)
|
|
|
|
class PartyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_party_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.team_no = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.party_team_data_list: List[PartyTeamData] = []
|
|
self.party_team_data_list, new_off = decode_arr_cls(data, off, PartyTeamData)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, user_party_id: int, team_num: int, member1: Dict, member2: Dict, member3: Dict) -> "PartyData":
|
|
ret = cls(b"\x00" * 9, 0)
|
|
ret.user_party_id = user_party_id
|
|
ret.team_no = team_num
|
|
ret.party_team_data_list = [
|
|
PartyTeamData.from_args(f"{user_party_id}-{team_num}-1", 1, member1),
|
|
PartyTeamData.from_args(f"{user_party_id}-{team_num}-2", 2, member2),
|
|
PartyTeamData.from_args(f"{user_party_id}-{team_num}-3", 3, member3),
|
|
]
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_party_id) \
|
|
+ encode_byte(self.team_no) \
|
|
+ encode_arr_cls(self.party_team_data_list)
|
|
|
|
class SupportLogPartyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.party_no = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.arrangement_num_1_user_support_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.arrangement_num_2_user_support_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.arrangement_num_3_user_support_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SupportLogPartyData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.party_no = data['PartyNo']
|
|
ret.arrangement_num_1_user_support_log_id = data['ArrangementNum1UserSupportLogId']
|
|
ret.arrangement_num_2_user_support_log_id = data['ArrangementNum2UserSupportLogId']
|
|
ret.arrangement_num_3_user_support_log_id = data['ArrangementNum3UserSupportLogId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.party_no) \
|
|
+ encode_str(self.arrangement_num_1_user_support_log_id) \
|
|
+ encode_str(self.arrangement_num_2_user_support_log_id) \
|
|
+ encode_str(self.arrangement_num_3_user_support_log_id)
|
|
|
|
class PlayStartRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
sz = 0
|
|
user_party_id = decode_str(data, offset + sz)
|
|
self.user_party_id = user_party_id[0]
|
|
sz += user_party_id[1]
|
|
|
|
appoint_leader_resource_card_code = decode_str(data, offset + sz)
|
|
self.appoint_leader_resource_card_code = appoint_leader_resource_card_code[0]
|
|
sz += appoint_leader_resource_card_code[1]
|
|
|
|
use_profile_card_code = decode_str(data, offset + sz)
|
|
self.use_profile_card_code = use_profile_card_code[0]
|
|
sz += use_profile_card_code[1]
|
|
|
|
self.quest_drop_boost_apply_flag = decode_byte(data, offset + sz)
|
|
sz += BYTE_OFF
|
|
|
|
self._sz = sz
|
|
|
|
class GetPlayerTraceData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
user_quest_scene_player_trace_id = decode_str(data, offset)
|
|
self.user_quest_scene_player_trace_id = user_quest_scene_player_trace_id[0]
|
|
self._sz = user_quest_scene_player_trace_id[1]
|
|
|
|
class BaseGetData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.get_hero_log_exp = decode_int(data, offset)
|
|
offset += INT_OFF
|
|
|
|
self.get_col = decode_int(data, offset)
|
|
|
|
self._sz = INT_OFF + INT_OFF
|
|
|
|
class RareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.quest_rare_drop_id = decode_int(data, offset)
|
|
|
|
self._sz = INT_OFF
|
|
|
|
class UnanalyzedLogTmpRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.unanalyzed_log_grade_id = decode_int(data, offset)
|
|
|
|
self._sz = INT_OFF
|
|
|
|
class SpecialRareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.quest_special_rare_drop_id = decode_int(data, offset)
|
|
|
|
self._sz = INT_OFF
|
|
|
|
class EventItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.event_item_id = decode_int(data, offset)
|
|
offset += INT_OFF
|
|
self.get_num = decode_short(data, offset)
|
|
|
|
self._sz = INT_OFF + SHORT_OFF
|
|
|
|
class DiscoveryEnemyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.enemy_kind_id = decode_int(data, offset)
|
|
offset += INT_OFF
|
|
self.destroy_num = decode_short(data, offset)
|
|
|
|
self._sz = INT_OFF + SHORT_OFF
|
|
|
|
class DestroyBossData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.boss_type = decode_byte(data, offset)
|
|
offset += BYTE_OFF
|
|
self.enemy_kind_id = decode_int(data, offset)
|
|
offset += INT_OFF
|
|
self.mission_difficulty_id = decode_short(data, offset)
|
|
|
|
self._sz = INT_OFF + SHORT_OFF + BYTE_OFF
|
|
|
|
class MissionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
self.mission_id = decode_int(data, offset)
|
|
offset += INT_OFF
|
|
self.clear_flag = decode_byte(data, offset)
|
|
offset += BYTE_OFF
|
|
self.destroy_num = decode_short(data, offset)
|
|
|
|
self._sz = INT_OFF + SHORT_OFF + BYTE_OFF
|
|
|
|
class ScoreData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.clear_time = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.combo_num = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
total_damage = decode_str(data, offset + self._sz)
|
|
self.total_damage = total_damage[0]
|
|
self._sz += total_damage[1]
|
|
|
|
self.concurrent_destroying_num = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
self.reaching_skill_level = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
self.ko_chara_num = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
|
|
self.acceleration_invocation_num = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
self.boss_destroying_num = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
self.synchro_skill_used_flag = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
|
|
self.used_friend_skill_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.friend_skill_used_flag = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
|
|
self.continue_cnt = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
self.total_loss_num = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
class PlayEndRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
sz = 0
|
|
self.play_result_flag = decode_byte(data, offset + sz)
|
|
sz += BYTE_OFF
|
|
|
|
self.base_get_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.base_get_data_list: List[BaseGetData] = []
|
|
for _ in range(self.base_get_data_count):
|
|
tmp = BaseGetData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.base_get_data_list.append(tmp)
|
|
|
|
self.get_player_trace_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.get_player_trace_data: List[GetPlayerTraceData] = []
|
|
for _ in range(self.get_player_trace_data_count):
|
|
tmp = GetPlayerTraceData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.get_player_trace_data.append(tmp)
|
|
|
|
self.get_rare_drop_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.get_rare_drop_data_list: List[RareDropData] = []
|
|
for _ in range(self.get_rare_drop_data_count):
|
|
tmp = RareDropData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.get_rare_drop_data_list.append(tmp)
|
|
|
|
self.get_special_rare_drop_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.get_special_rare_drop_data_list: List[SpecialRareDropData] = []
|
|
for _ in range(self.get_special_rare_drop_data_count):
|
|
tmp = SpecialRareDropData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.get_special_rare_drop_data_list.append(tmp)
|
|
|
|
self.get_unanalyzed_log_tmp_reward_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.get_unanalyzed_log_tmp_reward_data_list: List[UnanalyzedLogTmpRewardData] = []
|
|
for _ in range(self.get_unanalyzed_log_tmp_reward_data_count):
|
|
tmp = UnanalyzedLogTmpRewardData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.get_unanalyzed_log_tmp_reward_data_list.append(tmp)
|
|
|
|
self.get_event_item_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.get_event_item_data_list: List[EventItemData] = []
|
|
for _ in range(self.get_event_item_data_count):
|
|
tmp = EventItemData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.get_event_item_data_list.append(tmp)
|
|
|
|
self.discovery_enemy_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.discovery_enemy_data_list: List[DiscoveryEnemyData] = []
|
|
for _ in range(self.discovery_enemy_data_count):
|
|
tmp = DiscoveryEnemyData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.discovery_enemy_data_list.append(tmp)
|
|
|
|
self.destroy_boss_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.destroy_boss_data_list: List[DestroyBossData] = []
|
|
for _ in range(self.destroy_boss_data_count):
|
|
tmp = DestroyBossData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.destroy_boss_data_list.append(tmp)
|
|
|
|
self.mission_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.mission_data_list: List[MissionData] = []
|
|
for _ in range(self.mission_data_count):
|
|
tmp = MissionData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.mission_data_list.append(tmp)
|
|
|
|
self.score_data_count = decode_int(data, offset + sz)
|
|
sz += INT_OFF
|
|
|
|
self.score_data_list: List[ScoreData] = []
|
|
for _ in range(self.score_data_count):
|
|
tmp = ScoreData(data, offset + sz)
|
|
sz += tmp.get_size()
|
|
self.score_data_list.append(tmp)
|
|
|
|
self._sz = sz
|
|
|
|
class EntryUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
store_id = decode_str(data, offset + self._sz)
|
|
self.store_id = store_id[0]
|
|
self._sz += store_id[1]
|
|
|
|
user_id = decode_str(data, offset + self._sz)
|
|
self.user_id = user_id[0]
|
|
self._sz += user_id[1]
|
|
|
|
self.host_flag = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
|
|
class MultiPlayStartRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
room_id = decode_str(data, offset + self._sz)
|
|
self.room_id = room_id[0]
|
|
self._sz += room_id[1]
|
|
|
|
self.matching_mode = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
|
|
self.entry_user_data_count = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.entry_user_data_list: List[EntryUserData] = []
|
|
for _ in range(self.entry_user_data_count):
|
|
tmp = EntryUserData(data, offset + self._sz)
|
|
self._sz += tmp.get_size()
|
|
self.entry_user_data_list.append(tmp)
|
|
|
|
class MultiPlayEndRequestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.dummy_1 = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
self.dummy_2 = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
self.dummy_3 = decode_byte(data, offset + self._sz)
|
|
self._sz += BYTE_OFF
|
|
|
|
class SalesResourceData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.common_reward_type = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
self.common_reward_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property1_value1 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property1_value2 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property2_value1 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property2_value2 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property3_value1 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property3_value2 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property4_value1 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.property4_value2 = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
@classmethod
|
|
def from_args(cls, reward_type: int = 0, reward_id: int = 0) -> "SalesResourceData":
|
|
ret = cls(b"\x00" * 54, 0)
|
|
ret.common_reward_type = reward_type # short
|
|
ret.common_reward_id = reward_id # int
|
|
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
ret = b""
|
|
ret += encode_short(self.common_reward_type)
|
|
ret += encode_int(self.common_reward_id)
|
|
|
|
ret += encode_int(self.property1_property_id)
|
|
ret += encode_int(self.property1_value1)
|
|
ret += encode_int(self.property1_value2)
|
|
|
|
ret += encode_int(self.property2_property_id)
|
|
ret += encode_int(self.property2_value1)
|
|
ret += encode_int(self.property2_value2)
|
|
|
|
ret += encode_int(self.property3_property_id)
|
|
ret += encode_int(self.property3_value1)
|
|
ret += encode_int(self.property3_value2)
|
|
|
|
ret += encode_int(self.property4_property_id)
|
|
ret += encode_int(self.property4_value1)
|
|
ret += encode_int(self.property4_value2)
|
|
|
|
class ShopResourceSalesData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
user_shop_resource_id = decode_str(data, offset + self._sz)
|
|
self.user_shop_resource_id = user_shop_resource_id[0]
|
|
self._sz = user_shop_resource_id[1]
|
|
|
|
discharge_user_id = decode_str(data, offset + self._sz)
|
|
self.discharge_user_id = discharge_user_id[0]
|
|
self._sz = discharge_user_id[1]
|
|
|
|
self.remaining_num = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
self.purchase_num = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
sales_start_date = decode_str(data, offset + self._sz)
|
|
self.sales_start_date = prs_dt(sales_start_date[0])
|
|
self._sz = sales_start_date[1]
|
|
|
|
sales_resource_data_list = decode_arr_cls(data, offset + self._sz, SalesResourceData)
|
|
self.sales_resource_data_list: List[SalesResourceData] = sales_resource_data_list[0]
|
|
self._sz += sales_resource_data_list[1]
|
|
|
|
@classmethod
|
|
def from_args(cls, resource_id: str = "0", discharge_id: str = "0", remaining: int = 0, purchased: int = 0) -> "ShopResourceSalesData":
|
|
ret = cls(b"\x00" * 20, 0)
|
|
ret.user_shop_resource_id = resource_id
|
|
ret.discharge_user_id = discharge_id
|
|
ret.remaining_num = remaining # short
|
|
ret.purchase_num = purchased # short
|
|
ret.sales_start_date = prs_dt()
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_str(self.user_shop_resource_id)
|
|
ret += encode_str(self.discharge_user_id)
|
|
ret += encode_short(self.remaining_num)
|
|
ret += encode_short(self.purchase_num)
|
|
ret += encode_date_str(self.sales_start_date)
|
|
ret += encode_arr_cls(self.sales_resource_data_list)
|
|
return ret
|
|
|
|
class YuiMedalShopUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.yui_medal_shop_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.purchase_num = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
last_purchase_date = decode_str(data, offset + self._sz)
|
|
self.last_purchase_date = last_purchase_date[0]
|
|
self._sz += last_purchase_date[1]
|
|
|
|
@classmethod
|
|
def from_args(cls, yui_medal_shop_id: int = 0, purchase_num: int = 0, last_purchase_date: datetime = datetime.fromtimestamp(0)) -> "YuiMedalShopUserData":
|
|
ret = cls(b"\x00" * 20, 0)
|
|
ret.yui_medal_shop_id = yui_medal_shop_id
|
|
ret.purchase_num = purchase_num
|
|
ret.last_purchase_date = last_purchase_date
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_int(self.yui_medal_shop_id)
|
|
ret += encode_int(self.purchase_num)
|
|
ret += encode_date_str(self.last_purchase_date)
|
|
return ret
|
|
|
|
class GashaMedalShopUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.gasha_medal_shop_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
self.purchase_num = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
@classmethod
|
|
def from_args(cls, gasha_medal_shop_id: int = 0, purchase_num: int = 0) -> "GashaMedalShopUserData":
|
|
ret = cls(b"\x00" * 20, 0)
|
|
ret.gasha_medal_shop_id = gasha_medal_shop_id
|
|
ret.purchase_num = purchase_num
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_int(self.gasha_medal_shop_id)
|
|
ret += encode_int(self.purchase_num)
|
|
return ret
|
|
|
|
class QuestHierarchyProgressDegreesRankingData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.rank = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.trial_tower_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
user_id = decode_str(data, offset + self._sz)
|
|
self.user_id = user_id[0]
|
|
self._sz += user_id[1]
|
|
|
|
nick_name = decode_str(data, offset + self._sz)
|
|
self.nick_name = nick_name[0]
|
|
self._sz += nick_name[1]
|
|
|
|
self.setting_title_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.favorite_hero_log_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.favorite_hero_log_awakening_stage = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
self.favorite_support_log_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.favorite_support_log_awakening_stage = decode_short(data, offset + self._sz)
|
|
self._sz += SHORT_OFF
|
|
|
|
clear_time = decode_str(data, offset + self._sz)
|
|
self.clear_time = clear_time[0]
|
|
self._sz += clear_time[1]
|
|
|
|
@classmethod
|
|
def from_args(cls) -> "QuestHierarchyProgressDegreesRankingData":
|
|
ret = cls(b"\x00" * 36, 0)
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_int(self.rank)
|
|
ret += encode_int(self.trial_tower_id)
|
|
ret += encode_str(self.user_id)
|
|
ret += encode_str(self.nick_name)
|
|
ret += encode_int(self.setting_title_id)
|
|
ret += encode_int(self.favorite_hero_log_id)
|
|
ret += encode_short(self.favorite_hero_log_awakening_stage)
|
|
ret += encode_int(self.favorite_support_log_id)
|
|
ret += encode_short(self.favorite_support_log_awakening_stage)
|
|
ret += encode_str(self.clear_time)
|
|
return ret
|
|
|
|
class PopularHeroLogRankingData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
self.rank = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.hero_log_id = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
self.used_num = decode_int(data, offset + self._sz)
|
|
self._sz += INT_OFF
|
|
|
|
@classmethod
|
|
def from_args(cls, ranking: int, hero_id: int, used_num: int) -> "PopularHeroLogRankingData":
|
|
ret = cls(b"\x00" * 992, 0)
|
|
ret.rank = ranking
|
|
ret.hero_log_id = hero_id
|
|
ret.used_num = used_num
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_int(self.rank)
|
|
ret += encode_int(self.hero_log_id)
|
|
ret += encode_int(self.used_num)
|
|
return ret
|
|
|
|
class DefragMatchBasicUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.seed_flag = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.ad_confirm_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.total_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.have_league_score = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.class_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hall_of_fame_confirm_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self._sz = off
|
|
|
|
@classmethod
|
|
def from_args(cls, seed_flag: int = 0, ad_confirm_flag: int = 0, total_league_point: int = 0, league_score: int = 0, class_num: int = 1, hof_flag: int = 0) -> "DefragMatchBasicUserData":
|
|
ret = cls(b"\x00" * 12, 0)
|
|
ret.seed_flag = seed_flag
|
|
ret.ad_confirm_flag = ad_confirm_flag
|
|
ret.total_league_point = total_league_point
|
|
ret.have_league_score = league_score
|
|
ret.class_num = class_num
|
|
ret.hall_of_fame_confirm_flag = hof_flag
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_short(self.seed_flag)
|
|
ret += encode_byte(self.ad_confirm_flag)
|
|
ret += encode_int(self.total_league_point)
|
|
ret += encode_short(self.have_league_score)
|
|
ret += encode_short(self.class_num)
|
|
ret += encode_byte(self.hall_of_fame_confirm_flag)
|
|
return ret
|
|
|
|
class DefragMatchRankingUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.league_point_rank = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.league_score_rank = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.nick_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.setting_title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_hero_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.favorite_support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_support_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.have_league_score = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, profile: Dict) -> "DefragMatchRankingUserData":
|
|
ret = cls(b"\x00" * 34, 0)
|
|
ret.league_point_rank = 0
|
|
ret.league_score_rank = 0
|
|
ret.nick_name = profile['nick_name']
|
|
ret.setting_title_id = profile['setting_title_id']
|
|
ret.favorite_hero_log_id = profile['fav_hero']
|
|
ret.favorite_hero_log_awakening_stage = 0
|
|
ret.favorite_support_log_id = 0
|
|
ret.favorite_support_log_awakening_stage = 0
|
|
ret.total_league_point = 0
|
|
ret.have_league_score = 0
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.league_point_rank) \
|
|
+ encode_int(self.league_score_rank) \
|
|
+ encode_str(self.nick_name) \
|
|
+ encode_int(self.setting_title_id) \
|
|
+ encode_int(self.favorite_hero_log_id) \
|
|
+ encode_short(self.favorite_hero_log_awakening_stage) \
|
|
+ encode_int(self.favorite_support_log_id) \
|
|
+ encode_short(self.favorite_support_log_awakening_stage) \
|
|
+ encode_int(self.total_league_point) \
|
|
+ encode_short(self.have_league_score)
|
|
|
|
class DefragMatchLeaguePointRankingData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.rank = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.store_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.store_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.nick_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.setting_title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_hero_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.favorite_support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_support_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.class_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchLeaguePointRankingData":
|
|
ret = cls(b"\x00" * 42, 0)
|
|
ret.rank = data['Rank']
|
|
ret.user_id = data['UserId']
|
|
ret.store_id = data['StoreId']
|
|
ret.store_name = data['StoreName']
|
|
ret.nick_name = data['NickName']
|
|
ret.setting_title_id = data['SettingTitleId']
|
|
ret.favorite_hero_log_id = data['FavoriteHeroLogId']
|
|
ret.favorite_hero_log_awakening_stage = data['FavoriteHeroLogAwakeningStage']
|
|
ret.favorite_support_log_id = data['FavoriteSupportLogId']
|
|
ret.favorite_support_log_awakening_stage = data['FavoriteSupportLogAwakeningStage']
|
|
ret.class_num = data['ClassNum']
|
|
ret.total_league_point = data['TotalLeaguePoint']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.rank) \
|
|
+ encode_str(self.user_id) \
|
|
+ encode_str(self.store_id) \
|
|
+ encode_str(self.store_name) \
|
|
+ encode_str(self.nick_name) \
|
|
+ encode_int(self.setting_title_id) \
|
|
+ encode_int(self.favorite_hero_log_id) \
|
|
+ encode_short(self.favorite_hero_log_awakening_stage) \
|
|
+ encode_int(self.favorite_support_log_id) \
|
|
+ encode_short(self.favorite_support_log_awakening_stage) \
|
|
+ encode_short(self.class_num) \
|
|
+ encode_int(self.total_league_point)
|
|
|
|
class DefragMatchLeagueScoreRankingList(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.rank = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.store_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.store_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.nick_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.setting_title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_hero_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.favorite_support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_support_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.class_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.have_league_score = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
@classmethod
|
|
def from_args(cls) -> "DefragMatchLeagueScoreRankingList":
|
|
return cls(b"\x00" * 40, 0)
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_int(self.rank)
|
|
ret += encode_str(self.user_id)
|
|
ret += encode_str(self.store_id)
|
|
ret += encode_str(self.store_name)
|
|
ret += encode_str(self.nick_name)
|
|
|
|
ret += encode_int(self.setting_title_id)
|
|
ret += encode_int(self.favorite_hero_log_id)
|
|
ret += encode_short(self.favorite_hero_log_awakening_stage)
|
|
ret += encode_int(self.favorite_support_log_id)
|
|
ret += encode_short(self.favorite_support_log_awakening_stage)
|
|
ret += encode_short(self.class_num)
|
|
ret += encode_short(self.have_league_score)
|
|
return ret
|
|
|
|
class AppVersionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.version_app_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.applying_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
@classmethod
|
|
def from_args(cls, app_ver: int, start_date: datetime) -> BaseHelper:
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.version_app_id = app_ver
|
|
ret.applying_start_date = start_date
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
ret = encode_int(self.version_app_id)
|
|
ret += encode_date_str(self.applying_start_date)
|
|
return ret
|
|
|
|
class MatchingErrorData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = 0
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_4, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_5, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_6, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_7, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_8, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_9, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_10, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.error_occurred_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
def __str__(self) -> str:
|
|
s = f"User: {self.user_id} || "
|
|
s += f"Params: {self.param_1} {self.param_2} {self.param_3} {self.param_4} {self.param_5} {self.param_6} {self.param_7} {self.param_8} {self.param_9} {self.param_10} || "
|
|
s += f"Date: {self.error_occurred_date}"
|
|
return s
|
|
|
|
class ReadProfileCard(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.profile_card_code, new_off = decode_str(data, off) # ID of the QR code
|
|
off += new_off
|
|
self.nick_name = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rank_num = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
self.setting_title_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.skill_id = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
self.hero_log_hero_log_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_log_level = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
self.hero_log_awakening_stage = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_property1_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property1_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property1_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property2_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property2_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property2_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property3_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property3_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property3_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property4_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property4_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.hero_log_property4_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_equipment_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_enhancement_value = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
self.main_weapon_awakening_stage = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
|
|
self.main_weapon_property1_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property1_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property1_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property2_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property2_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property2_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property3_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property3_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property3_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property4_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property4_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.main_weapon_property4_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_equipment_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_enhancement_value = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
self.sub_equipment_awakening_stage = decode_short(data, off) #short
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equipment_property1_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property1_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property1_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property2_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property2_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property2_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property3_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property3_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property3_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property4_property_id = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property4_value1 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
self.sub_equipment_property4_value2 = decode_int(data, off) #int
|
|
off += INT_OFF
|
|
|
|
self.holographic_flag = decode_byte(data, off) #byte
|
|
off += BYTE_OFF
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, code: str, player_name: str) -> "ReadProfileCard":
|
|
resp = cls(b"\x00" * 44, 0)
|
|
resp.profile_card_code = code # ID of the QR code
|
|
resp.nick_name = player_name
|
|
resp.rank_num = 1 #short
|
|
resp.setting_title_id = 20005 #int
|
|
resp.skill_id = 0 #short
|
|
resp.hero_log_hero_log_id = 118000230 #int
|
|
resp.hero_log_log_level = 1 #short
|
|
resp.hero_log_awakening_stage = 1 #short
|
|
|
|
resp.hero_log_property1_property_id = 0 #int
|
|
resp.hero_log_property1_value1 = 0 #int
|
|
resp.hero_log_property1_value2 = 0 #int
|
|
resp.hero_log_property2_property_id = 0 #int
|
|
resp.hero_log_property2_value1 = 0 #int
|
|
resp.hero_log_property2_value2 = 0 #int
|
|
resp.hero_log_property3_property_id = 0 #int
|
|
resp.hero_log_property3_value1 = 0 #int
|
|
resp.hero_log_property3_value2 = 0 #int
|
|
resp.hero_log_property4_property_id = 0 #int
|
|
resp.hero_log_property4_value1 = 0 #int
|
|
resp.hero_log_property4_value2 = 0 #int
|
|
|
|
resp.main_weapon_equipment_id = 0 #int
|
|
resp.main_weapon_enhancement_value = 0 #short
|
|
resp.main_weapon_awakening_stage = 0 #short
|
|
|
|
resp.main_weapon_property1_property_id = 0 #int
|
|
resp.main_weapon_property1_value1 = 0 #int
|
|
resp.main_weapon_property1_value2 = 0 #int
|
|
resp.main_weapon_property2_property_id = 0 #int
|
|
resp.main_weapon_property2_value1 = 0 #int
|
|
resp.main_weapon_property2_value2 = 0 #int
|
|
resp.main_weapon_property3_property_id = 0 #int
|
|
resp.main_weapon_property3_value1 = 0 #int
|
|
resp.main_weapon_property3_value2 = 0 #int
|
|
resp.main_weapon_property4_property_id = 0 #int
|
|
resp.main_weapon_property4_value1 = 0 #int
|
|
resp.main_weapon_property4_value2 = 0 #int
|
|
|
|
resp.sub_equipment_equipment_id = 0 #int
|
|
resp.sub_equipment_enhancement_value = 0 #short
|
|
resp.sub_equipment_awakening_stage = 0 #short
|
|
|
|
resp.sub_equipment_property1_property_id = 0 #int
|
|
resp.sub_equipment_property1_value1 = 0 #int
|
|
resp.sub_equipment_property1_value2 = 0 #int
|
|
resp.sub_equipment_property2_property_id = 0 #int
|
|
resp.sub_equipment_property2_value1 = 0 #int
|
|
resp.sub_equipment_property2_value2 = 0 #int
|
|
resp.sub_equipment_property3_property_id = 0 #int
|
|
resp.sub_equipment_property3_value1 = 0 #int
|
|
resp.sub_equipment_property3_value2 = 0 #int
|
|
resp.sub_equipment_property4_property_id = 0 #int
|
|
resp.sub_equipment_property4_value1 = 0 #int
|
|
resp.sub_equipment_property4_value2 = 0 #int
|
|
|
|
resp.holographic_flag = 0 #byte
|
|
return resp
|
|
|
|
class HeroLogUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.user_hero_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
self.hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.log_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.max_log_level_extended_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.log_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.possible_awakening_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self.awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.awakening_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.skill_slot_correction_value = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self.last_set_skill_slot1_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.last_set_skill_slot2_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.last_set_skill_slot3_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.last_set_skill_slot4_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.last_set_skill_slot5_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.converted_card_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.shop_purchase_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self.protect_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
get_date, new_off = decode_str(data, off)
|
|
off += new_off
|
|
self.get_date = prs_dt(get_date)
|
|
self.sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, hero_data: Dict) -> "HeroLogUserData":
|
|
ret = cls(b"\x00" * 90, 0)
|
|
# Seems user_hero_log_id is a globally unique identifier, while hero_log_id identifies the hero
|
|
ret.user_hero_log_id = f"{hero_data['id']}"
|
|
ret.hero_log_id = hero_data['hero_log_id']
|
|
|
|
ret.log_level = hero_data['log_level']
|
|
ret.max_log_level_extended_num = hero_data['max_level_extend_num']
|
|
ret.log_exp = hero_data['log_exp']
|
|
|
|
ret.possible_awakening_flag = hero_data['is_awakenable']
|
|
ret.awakening_stage = hero_data['awakening_stage']
|
|
ret.awakening_exp = hero_data['awakening_exp']
|
|
|
|
ret.skill_slot_correction_value = 0 # Allows unlocking skill slot 4 and 5 early
|
|
ret.last_set_skill_slot1_skill_id = hero_data['skill_slot1_skill_id']
|
|
ret.last_set_skill_slot2_skill_id = hero_data['skill_slot2_skill_id']
|
|
ret.last_set_skill_slot3_skill_id = hero_data['skill_slot3_skill_id']
|
|
ret.last_set_skill_slot4_skill_id = hero_data['skill_slot4_skill_id']
|
|
ret.last_set_skill_slot5_skill_id = hero_data['skill_slot5_skill_id']
|
|
|
|
ret.property1_property_id = hero_data['property1_property_id']
|
|
ret.property1_value1 = hero_data['property1_value1']
|
|
ret.property1_value2 = hero_data['property1_value2']
|
|
ret.property2_property_id = hero_data['property2_property_id']
|
|
ret.property2_value1 = hero_data['property2_value1']
|
|
ret.property2_value2 = hero_data['property2_value2']
|
|
ret.property3_property_id = hero_data['property2_property_id']
|
|
ret.property3_value1 = hero_data['property3_value1']
|
|
ret.property3_value2 = hero_data['property3_value2']
|
|
ret.property4_property_id = hero_data['property2_property_id']
|
|
ret.property4_value1 = hero_data['property4_value1']
|
|
ret.property4_value2 = hero_data['property4_value2']
|
|
|
|
ret.converted_card_num = hero_data['converted_card_num']
|
|
ret.shop_purchase_flag = hero_data['is_shop_purchase']
|
|
ret.protect_flag = hero_data['is_protect']
|
|
ret.get_date = hero_data['get_date']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_hero_log_id) \
|
|
+ encode_int(self.hero_log_id) \
|
|
+ encode_short(self.log_level) \
|
|
+ encode_short(self.max_log_level_extended_num) \
|
|
+ encode_int(self.log_exp) \
|
|
+ encode_byte(self.possible_awakening_flag) \
|
|
+ encode_short(self.awakening_stage) \
|
|
+ encode_int(self.awakening_exp) \
|
|
+ encode_byte(self.skill_slot_correction_value) \
|
|
+ encode_short(self.last_set_skill_slot1_skill_id) \
|
|
+ encode_short(self.last_set_skill_slot2_skill_id) \
|
|
+ encode_short(self.last_set_skill_slot3_skill_id) \
|
|
+ encode_short(self.last_set_skill_slot4_skill_id) \
|
|
+ encode_short(self.last_set_skill_slot5_skill_id) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2) \
|
|
+ encode_short(self.converted_card_num) \
|
|
+ encode_byte(self.shop_purchase_flag) \
|
|
+ encode_byte(self.protect_flag) \
|
|
+ encode_date_str(self.get_date)
|
|
|
|
class YuiMedalBonusUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.elapsed_days = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.loop_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
last_check_date, new_off = decode_str(data, off)
|
|
off += new_off
|
|
self.last_check_date = prs_dt(last_check_date)
|
|
|
|
last_get_date, new_off = decode_str(data, off)
|
|
off += new_off
|
|
self.last_get_date = prs_dt(last_get_date)
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, elapsed_days: int = 0, loop_num: int = 0) -> BaseHelper:
|
|
ret = cls(b"\x00" * 996, 0)
|
|
ret.elapsed_days = elapsed_days
|
|
ret.loop_num = loop_num
|
|
ret.last_check_date = datetime.fromtimestamp(0)
|
|
ret.last_get_date = datetime.fromtimestamp(0)
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.elapsed_days) \
|
|
+ encode_int(self.loop_num) \
|
|
+ encode_date_str(self.last_check_date) \
|
|
+ encode_date_str(self.last_get_date)
|
|
|
|
class UserBasicData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.user_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.nick_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rank_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.rank_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.own_col = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.own_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.own_yui_medal = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.setting_title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.favorite_user_hero_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.favorite_user_support_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.my_store_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.my_store_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
user_reg_date, new_off = decode_str(data, off)
|
|
self.user_reg_date = prs_dt(user_reg_date)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, profile_data: Dict, shop_name: str = "ARTEMiS") -> "UserBasicData":
|
|
ret = cls(b"\0" * 52, 0)
|
|
ret.user_type = profile_data['user_type']
|
|
ret.nick_name = profile_data['nick_name']
|
|
ret.rank_num = profile_data['rank_num']
|
|
ret.rank_exp = profile_data['rank_exp']
|
|
ret.own_col = profile_data['own_col']
|
|
ret.own_vp = profile_data['own_vp']
|
|
ret.own_yui_medal = profile_data['own_yui_medal']
|
|
ret.setting_title_id = profile_data['setting_title_id']
|
|
ret.favorite_user_hero_log_id = profile_data['fav_hero']
|
|
ret.favorite_user_support_log_id = "" # TODO: Supports
|
|
ret.my_store_id = "JPN0" + f"{profile_data['my_shop']:04X}" if profile_data["my_shop"] else "0"
|
|
ret.my_store_name = shop_name
|
|
ret.user_reg_date = profile_data['when_register'] if profile_data['when_register'] else prs_dt("20230101120000")
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.user_type) \
|
|
+ encode_str(self.nick_name) \
|
|
+ encode_short(self.rank_num) \
|
|
+ encode_int(self.rank_exp) \
|
|
+ encode_int(self.own_col) \
|
|
+ encode_int(self.own_vp) \
|
|
+ encode_int(self.own_yui_medal) \
|
|
+ encode_int(self.setting_title_id) \
|
|
+ encode_str(self.favorite_user_hero_log_id) \
|
|
+ encode_str(self.favorite_user_support_log_id) \
|
|
+ encode_str(self.my_store_id) \
|
|
+ encode_str(self.my_store_name) \
|
|
+ encode_date_str(self.user_reg_date) \
|
|
|
|
class VpGashaTicketData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.remaining_own_vp_gasha_ticket = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.expire_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, ticket_remain: int, exp_date: datetime) -> "VpGashaTicketData":
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.remaining_own_vp_gasha_ticket = ticket_remain
|
|
ret.expire_date = exp_date
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.remaining_own_vp_gasha_ticket) \
|
|
+ encode_date_str(self.expire_date)
|
|
|
|
class BeginnerMissionUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ad_confirm_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.ad_confirm_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, confirm_date: datetime, confirm_flg: bool = False) -> "BeginnerMissionUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ad_confirm_flag = confirm_flg
|
|
ret.ad_confirm_date = confirm_date
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.ad_confirm_flag) \
|
|
+ encode_date_str(self.ad_confirm_date)
|
|
|
|
class EquipmentUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.user_equipment_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.equipment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.enhancement_value = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.max_enhancement_value_extended_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.enhancement_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.possible_awakening_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self.awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.awakening_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.converted_card_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
self.shop_purchase_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self.protect_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.get_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, equip_data: Dict) -> "EquipmentUserData":
|
|
ret = cls(b"\x00" * 79, 0)
|
|
ret.user_equipment_id = str(equip_data['id'])
|
|
ret.equipment_id = equip_data['equipment_id']
|
|
ret.enhancement_value = equip_data['enhancement_value']
|
|
ret.max_enhancement_value_extended_num = 0 #equip_data['max_enhancement_value_extended_num'] TODO: This
|
|
ret.enhancement_exp = equip_data['enhancement_exp']
|
|
ret.possible_awakening_flag = equip_data['possible_awakening_flag']
|
|
ret.awakening_stage = equip_data['awakening_stage']
|
|
ret.awakening_exp = equip_data['awakening_exp']
|
|
ret.property1_property_id = equip_data['property1_property_id']
|
|
ret.property1_value1 = equip_data['property1_value1']
|
|
ret.property1_value2 = equip_data['property1_value2']
|
|
ret.property2_property_id = equip_data['property2_property_id']
|
|
ret.property2_value1 = equip_data['property2_value1']
|
|
ret.property2_value2 = equip_data['property2_value2']
|
|
ret.property3_property_id = equip_data['property2_property_id']
|
|
ret.property3_value1 = equip_data['property3_value1']
|
|
ret.property3_value2 = equip_data['property3_value2']
|
|
ret.property4_property_id = equip_data['property2_property_id']
|
|
ret.property4_value1 = equip_data['property4_value1']
|
|
ret.property4_value2 = equip_data['property4_value2']
|
|
ret.converted_card_num = equip_data['converted_card_num']
|
|
ret.shop_purchase_flag = equip_data['is_shop_purchase']
|
|
ret.protect_flag = equip_data['is_protect']
|
|
ret.get_date = equip_data['get_date']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return encode_str(self.user_equipment_id) \
|
|
+ encode_int(self.equipment_id) \
|
|
+ encode_short(self.enhancement_value) \
|
|
+ encode_short(self.max_enhancement_value_extended_num) \
|
|
+ encode_int(self.enhancement_exp) \
|
|
+ encode_byte(self.possible_awakening_flag) \
|
|
+ encode_short(self.awakening_stage) \
|
|
+ encode_int(self.awakening_exp) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2) \
|
|
+ encode_short(self.converted_card_num) \
|
|
+ encode_byte(self.shop_purchase_flag) \
|
|
+ encode_byte(self.protect_flag) \
|
|
+ encode_date_str(self.get_date)
|
|
|
|
class ItemUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int) -> None:
|
|
super().__init__(data, offset)
|
|
off = offset
|
|
self.user_item_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
self.item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
self.protect_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
self.get_date = decode_date_str(data, off)
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, item_data: Dict) -> BaseHelper:
|
|
ret = cls(b"\x00" * 993, 0)
|
|
ret.user_item_id = str(item_data['id'])
|
|
ret.item_id = item_data['item_id']
|
|
ret.protect_flag = 0
|
|
ret.get_date = item_data['get_date']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return encode_str(self.user_item_id) \
|
|
+ encode_int(self.item_id) \
|
|
+ encode_byte(self.protect_flag) \
|
|
+ encode_date_str(self.get_date)
|
|
|
|
class SupportLogUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_support_log_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.possible_awakening_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.awakening_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.converted_card_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.shop_purchase_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.protect_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.get_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, user_support_log: str, support_log: int) -> "SupportLogUserData":
|
|
ret = cls(b"\x00" * 23, 0)
|
|
ret.user_support_log_id = user_support_log
|
|
ret.support_log_id = support_log
|
|
ret.possible_awakening_flag = 0
|
|
ret.awakening_stage = 0
|
|
ret.awakening_exp = 0
|
|
ret.converted_card_num = 0
|
|
ret.shop_purchase_flag = 0
|
|
ret.protect_flag = 0
|
|
ret.get_date = prs_dt()
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_support_log_id) \
|
|
+ encode_int(self.support_log_id) \
|
|
+ encode_byte(self.possible_awakening_flag) \
|
|
+ encode_short(self.awakening_stage) \
|
|
+ encode_int(self.awakening_exp) \
|
|
+ encode_short(self.converted_card_num) \
|
|
+ encode_byte(self.shop_purchase_flag) \
|
|
+ encode_byte(self.protect_flag) \
|
|
+ encode_date_str(self.get_date)
|
|
|
|
class EventItemUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_event_item_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.event_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.own_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EventItemUserData":
|
|
ret = cls(b"\x00" * 996, 0)
|
|
ret.user_event_item_id = data['UserEventItemId']
|
|
ret.user_id = data['UserId']
|
|
ret.event_item_id = data['EventItemId']
|
|
ret.own_num = data['OwnNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_event_item_id) \
|
|
+ encode_str(self.user_id) \
|
|
+ encode_int(self.event_item_id) \
|
|
+ encode_int(self.own_num)
|
|
|
|
class GashaMedalUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_gasha_medal_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.gasha_medal_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.own_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalUserData":
|
|
ret = cls(b"\x00" * 996, 0)
|
|
ret.user_gasha_medal_id = data['UserGashaMedalId']
|
|
ret.user_id = data['UserId']
|
|
ret.gasha_medal_id = data['GashaMedalId']
|
|
ret.own_num = data['OwnNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_gasha_medal_id) \
|
|
+ encode_str(self.user_id) \
|
|
+ encode_int(self.gasha_medal_id) \
|
|
+ encode_int(self.own_num)
|
|
|
|
class TitleUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_title_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, user_title_id: str, title_id: int) -> "TitleUserData":
|
|
ret = cls(b"\x00" * 8, 0)
|
|
ret.user_title_id = user_title_id
|
|
ret.title_id = title_id
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_title_id) \
|
|
+ encode_int(self.title_id)
|
|
|
|
class PlayerRankData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.player_rank_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.storage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.team_preset = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PlayerRankData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.player_rank_id = data['PlayerRankId']
|
|
ret.total_exp = data['TotalExp']
|
|
ret.storage = data['Storage']
|
|
ret.team_preset = data['TeamPreset']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.player_rank_id) \
|
|
+ encode_int(self.total_exp) \
|
|
+ encode_short(self.storage) \
|
|
+ encode_short(self.team_preset)
|
|
|
|
class TitleData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.requirement = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.rank = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.image_file_path, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TitleData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.title_id = data['TitleId']
|
|
ret.display_name = data['DisplayName']
|
|
ret.requirement = data['Requirement']
|
|
ret.value1 = data['Value1']
|
|
ret.value2 = data['Value2']
|
|
ret.rank = data['Rank']
|
|
ret.image_file_path = data['ImageFilePath']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.title_id) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.requirement) \
|
|
+ encode_int(self.value1) \
|
|
+ encode_int(self.value2) \
|
|
+ encode_int(self.rank) \
|
|
+ encode_str(self.image_file_path)
|
|
|
|
class FragmentData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.fragment_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.comment_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "FragmentData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.fragment_id = data['FragmentId']
|
|
ret.exp = data['Exp']
|
|
ret.comment_id = data['CommentId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.fragment_id) \
|
|
+ encode_int(self.exp) \
|
|
+ encode_str(self.comment_id)
|
|
|
|
class RewardTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.reward_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.reward_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unanalyzed_log_grade_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_info_display_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "RewardTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.reward_table_id = data['RewardTableId']
|
|
ret.reward_table_sub_id = data['RewardTableSubId']
|
|
ret.unanalyzed_log_grade_id = data['UnanalyzedLogGradeId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength_min = data['StrengthMin']
|
|
ret.strength_max = data['StrengthMax']
|
|
ret.property_table_sub_id = data['PropertyTableSubId']
|
|
ret.rate = data['Rate']
|
|
ret.quest_info_display_flag = data['QuestInfoDisplayFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.reward_table_id) \
|
|
+ encode_int(self.reward_table_sub_id) \
|
|
+ encode_int(self.unanalyzed_log_grade_id) \
|
|
+ encode_int(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num) \
|
|
+ encode_int(self.strength_min) \
|
|
+ encode_int(self.strength_max) \
|
|
+ encode_int(self.property_table_sub_id) \
|
|
+ encode_int(self.rate) \
|
|
+ encode_byte(self.quest_info_display_flag)
|
|
|
|
class RewardSetData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.reward_set_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.reward_set_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "RewardSetData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.reward_set_id = data['RewardSetId']
|
|
ret.reward_set_sub_id = data['RewardSetSubId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.reward_set_id) \
|
|
+ encode_int(self.reward_set_sub_id) \
|
|
+ encode_int(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class UnanalyzedLogGradeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unanalyzed_log_grade_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "UnanalyzedLogGradeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.unanalyzed_log_grade_id = data['UnanalyzedLogGradeId']
|
|
ret.name = data['Name']
|
|
ret.comment_id = data['CommentId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unanalyzed_log_grade_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.comment_id)
|
|
|
|
class AppointLeaderParamData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.appoint_leader_param_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.initial_synchro_rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appoint_leader_increment_synchro_rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_increment_synchro_rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.foil_add_synchro_rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appoint_leader_trust_bonus = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AppointLeaderParamData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.appoint_leader_param_id = data['AppointLeaderParamId']
|
|
ret.initial_synchro_rate = data['InitialSynchroRate']
|
|
ret.appoint_leader_increment_synchro_rate = data['AppointLeaderIncrementSynchroRate']
|
|
ret.awakening_increment_synchro_rate = data['AwakeningIncrementSynchroRate']
|
|
ret.foil_add_synchro_rate = data['FoilAddSynchroRate']
|
|
ret.appoint_leader_trust_bonus = data['AppointLeaderTrustBonus']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.appoint_leader_param_id) \
|
|
+ encode_int(self.initial_synchro_rate) \
|
|
+ encode_int(self.appoint_leader_increment_synchro_rate) \
|
|
+ encode_int(self.awakening_increment_synchro_rate) \
|
|
+ encode_int(self.foil_add_synchro_rate) \
|
|
+ encode_int(self.appoint_leader_trust_bonus)
|
|
|
|
class AppointLeaderEffectData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.appoint_leader_effect_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.info_text_format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.appoint_leader_effect_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.low_effect_value, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.middle_effect_value, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.high_effect_value, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.max_effect_value, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AppointLeaderEffectData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.appoint_leader_effect_id = data['AppointLeaderEffectId']
|
|
ret.chara_id = data['CharaId']
|
|
ret.info_text_format = data['InfoTextFormat']
|
|
ret.appoint_leader_effect_type_id = data['AppointLeaderEffectTypeId']
|
|
ret.low_effect_value = data['LowEffectValue']
|
|
ret.middle_effect_value = data['MiddleEffectValue']
|
|
ret.high_effect_value = data['HighEffectValue']
|
|
ret.max_effect_value = data['MaxEffectValue']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.appoint_leader_effect_id) \
|
|
+ encode_short(self.chara_id) \
|
|
+ encode_str(self.info_text_format) \
|
|
+ encode_short(self.appoint_leader_effect_type_id) \
|
|
+ encode_str(self.low_effect_value) \
|
|
+ encode_str(self.middle_effect_value) \
|
|
+ encode_str(self.high_effect_value) \
|
|
+ encode_str(self.max_effect_value)
|
|
|
|
class AppointLeaderEffectTypeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.appoint_leader_effect_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AppointLeaderEffectTypeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.appoint_leader_effect_type_id = data['AppointLeaderEffectTypeId']
|
|
ret.name = data['Name']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.appoint_leader_effect_type_id) \
|
|
+ encode_str(self.name)
|
|
|
|
class RarityData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.rarity_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.require_col_my_card = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.require_col_other_card = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.require_medal_other_card = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.synthesis_exp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "RarityData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.rarity_id = data['RarityId']
|
|
ret.require_col_my_card = data['RequireColMyCard']
|
|
ret.require_col_other_card = data['RequireColOtherCard']
|
|
ret.require_medal_other_card = data['RequireMedalOtherCard']
|
|
ret.synthesis_exp_rate = data['SynthesisExpRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.rarity_id) \
|
|
+ encode_int(self.require_col_my_card) \
|
|
+ encode_int(self.require_col_other_card) \
|
|
+ encode_int(self.require_medal_other_card) \
|
|
+ encode_str(self.synthesis_exp_rate)
|
|
|
|
class CompositionEventData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.composition_event_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.composition_exp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.awakening_exp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CompositionEventData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.composition_event_id = data['CompositionEventId']
|
|
ret.composition_exp_rate = data['CompositionExpRate']
|
|
ret.awakening_exp_rate = data['AwakeningExpRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.composition_event_id) \
|
|
+ encode_str(self.composition_exp_rate) \
|
|
+ encode_str(self.awakening_exp_rate)
|
|
|
|
class CompositionParamData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.composition_param_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.use_value = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.max_extended_use_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.awakening_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.use_value_support_log = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CompositionParamData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.composition_param_id = data['CompositionParamId']
|
|
ret.use_value = data['UseValue']
|
|
ret.max_extended_use_coef = data['MaxExtendedUseCoef']
|
|
ret.awakening_coef = data['AwakeningCoef']
|
|
ret.use_value_support_log = data['UseValueSupportLog']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.composition_param_id) \
|
|
+ encode_int(self.use_value) \
|
|
+ encode_str(self.max_extended_use_coef) \
|
|
+ encode_str(self.awakening_coef) \
|
|
+ encode_int(self.use_value_support_log)
|
|
|
|
class GamePlayPriceData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.game_play_price_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.player_rank_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.episode_ticket = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.trial_tower_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.custom_retry_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.subdue_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.continue_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.continue_credit = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.extend_time_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.reward_grade_up_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.reward_grade_up_credit = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.give_free_ticket = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.free_continue_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GamePlayPriceData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.game_play_price_id = data['GamePlayPriceId']
|
|
ret.player_rank_id = data['PlayerRankId']
|
|
ret.episode_ticket = data['EpisodeTicket']
|
|
ret.trial_tower_ticket = data['TrialTowerTicket']
|
|
ret.custom_retry_ticket = data['CustomRetryTicket']
|
|
ret.subdue_ticket = data['SubdueTicket']
|
|
ret.continue_ticket = data['ContinueTicket']
|
|
ret.continue_credit = data['ContinueCredit']
|
|
ret.extend_time_ticket = data['ExtendTimeTicket']
|
|
ret.reward_grade_up_ticket = data['RewardGradeUpTicket']
|
|
ret.reward_grade_up_credit = data['RewardGradeUpCredit']
|
|
ret.give_free_ticket = data['GiveFreeTicket']
|
|
ret.free_continue_num = data['FreeContinueNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.game_play_price_id) \
|
|
+ encode_short(self.player_rank_id) \
|
|
+ encode_int(self.episode_ticket) \
|
|
+ encode_short(self.trial_tower_ticket) \
|
|
+ encode_short(self.custom_retry_ticket) \
|
|
+ encode_short(self.subdue_ticket) \
|
|
+ encode_short(self.continue_ticket) \
|
|
+ encode_short(self.continue_credit) \
|
|
+ encode_short(self.extend_time_ticket) \
|
|
+ encode_short(self.reward_grade_up_ticket) \
|
|
+ encode_short(self.reward_grade_up_credit) \
|
|
+ encode_short(self.give_free_ticket) \
|
|
+ encode_short(self.free_continue_num)
|
|
|
|
class BuyTicketData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.buy_ticket_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.buy_ticket_pattern = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.credit_cnt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_ticket_cnt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_bonus_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BuyTicketData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.buy_ticket_id = data['BuyTicketId']
|
|
ret.buy_ticket_pattern = data['BuyTicketPattern']
|
|
ret.credit_cnt = data['CreditCnt']
|
|
ret.get_ticket_cnt = data['GetTicketCnt']
|
|
ret.get_bonus_vp = data['GetBonusVp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.buy_ticket_id) \
|
|
+ encode_int(self.buy_ticket_pattern) \
|
|
+ encode_int(self.credit_cnt) \
|
|
+ encode_int(self.get_ticket_cnt) \
|
|
+ encode_int(self.get_bonus_vp)
|
|
|
|
class TipsData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.tips_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.tips_category = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.tips_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TipsData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.tips_id = data['TipsId']
|
|
ret.tips_category = data['TipsCategory']
|
|
ret.tips_text = data['TipsText']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.tips_id) \
|
|
+ encode_byte(self.tips_category) \
|
|
+ encode_str(self.tips_text)
|
|
|
|
class CapData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.cap_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.trust1_cap = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CapData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.cap_id = data['CapId']
|
|
ret.trust1_cap = data['Trust1Cap']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.cap_id) \
|
|
+ encode_int(self.trust1_cap)
|
|
|
|
class HeroLogData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.nickname, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rarity = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.weapon_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_role_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.costume_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.default_equipment_id1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.default_equipment_id2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hp_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hp_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.str_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.str_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.vit_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.vit_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.int_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.int_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sale_price = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.composition_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.slot4_unlock_level = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.slot5_unlock_level = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.cut_in_image, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cut_in_image_awake, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cut_in_upper_side_text = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.chara_comment_image, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.chara_comment_image_awake, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_start_introduce, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_start_introduce_awake, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_chara_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_chara_icon_awake, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_chara_icon_loss, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_chara_icon_awake_loss, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_display_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_empty_frame_display_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "HeroLogData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.hero_log_id = data['HeroLogId']
|
|
ret.chara_id = data['CharaId']
|
|
ret.name = data['Name']
|
|
ret.nickname = data['Nickname']
|
|
ret.rarity = data['Rarity']
|
|
ret.weapon_type_id = data['WeaponTypeId']
|
|
ret.hero_log_role_id = data['HeroLogRoleId']
|
|
ret.costume_type_id = data['CostumeTypeId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.default_equipment_id1 = data['DefaultEquipmentId1']
|
|
ret.default_equipment_id2 = data['DefaultEquipmentId2']
|
|
ret.skill_table_sub_id = data['SkillTableSubId']
|
|
ret.hp_min = data['HpMin']
|
|
ret.hp_max = data['HpMax']
|
|
ret.str_min = data['StrMin']
|
|
ret.str_max = data['StrMax']
|
|
ret.vit_min = data['VitMin']
|
|
ret.vit_max = data['VitMax']
|
|
ret.int_min = data['IntMin']
|
|
ret.int_max = data['IntMax']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
ret.flavor_text = data['FlavorText']
|
|
ret.sale_price = data['SalePrice']
|
|
ret.composition_exp = data['CompositionExp']
|
|
ret.awakening_exp = data['AwakeningExp']
|
|
ret.slot4_unlock_level = data['Slot4UnlockLevel']
|
|
ret.slot5_unlock_level = data['Slot5UnlockLevel']
|
|
ret.cut_in_image = data['CutinImage']
|
|
ret.cut_in_image_awake = data['CutinImageAwake']
|
|
ret.cut_in_upper_side_text = data['CutinUpperSideText']
|
|
ret.chara_comment_image = data['CharaCommentImage']
|
|
ret.chara_comment_image_awake = data['CharaCommentImageAwake']
|
|
ret.quest_start_introduce = data['QuestStartIntroduce']
|
|
ret.quest_start_introduce_awake = data['QuestStartIntroduceAwake']
|
|
ret.quest_chara_icon = data['QuestCharaIcon']
|
|
ret.quest_chara_icon_awake = data['QuestCharaIconAwake']
|
|
ret.quest_chara_icon_loss = data['QuestCharaIconLoss']
|
|
ret.quest_chara_icon_awake_loss = data['QuestCharaIconAwakeLoss']
|
|
ret.collection_display_start_date = data['CollectionDisplayStartDate']
|
|
ret.collection_empty_frame_display_flag = data['CollectionEmptyFrameDisplayFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.hero_log_id) \
|
|
+ encode_short(self.chara_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.nickname) \
|
|
+ encode_byte(self.rarity) \
|
|
+ encode_short(self.weapon_type_id) \
|
|
+ encode_short(self.hero_log_role_id) \
|
|
+ encode_short(self.costume_type_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.default_equipment_id1) \
|
|
+ encode_int(self.default_equipment_id2) \
|
|
+ encode_int(self.skill_table_sub_id) \
|
|
+ encode_int(self.hp_min) \
|
|
+ encode_int(self.hp_max) \
|
|
+ encode_int(self.str_min) \
|
|
+ encode_int(self.str_max) \
|
|
+ encode_int(self.vit_min) \
|
|
+ encode_int(self.vit_max) \
|
|
+ encode_int(self.int_min) \
|
|
+ encode_int(self.int_max) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2) \
|
|
+ encode_str(self.flavor_text) \
|
|
+ encode_int(self.sale_price) \
|
|
+ encode_int(self.composition_exp) \
|
|
+ encode_int(self.awakening_exp) \
|
|
+ encode_int(self.slot4_unlock_level) \
|
|
+ encode_int(self.slot5_unlock_level) \
|
|
+ encode_str(self.cut_in_image) \
|
|
+ encode_str(self.cut_in_image_awake) \
|
|
+ encode_byte(self.cut_in_upper_side_text) \
|
|
+ encode_str(self.chara_comment_image) \
|
|
+ encode_str(self.chara_comment_image_awake) \
|
|
+ encode_str(self.quest_start_introduce) \
|
|
+ encode_str(self.quest_start_introduce_awake) \
|
|
+ encode_str(self.quest_chara_icon) \
|
|
+ encode_str(self.quest_chara_icon_awake) \
|
|
+ encode_str(self.quest_chara_icon_loss) \
|
|
+ encode_str(self.quest_chara_icon_awake_loss) \
|
|
+ encode_date_str(self.collection_display_start_date) \
|
|
+ encode_byte(self.collection_empty_frame_display_flag)
|
|
|
|
class HeroLogLevelData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.require_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.total_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "HeroLogLevelData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.level = data['HeroLogLevelId']
|
|
ret.require_exp = data['RequireExp']
|
|
ret.total_exp = data['TotalExp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.level) \
|
|
+ encode_int(self.require_exp) \
|
|
+ encode_int(self.total_exp)
|
|
|
|
class HeroLogRoleData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.hero_log_role_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "HeroLogRoleData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.hero_log_role_id = data['HeroLogRoleId']
|
|
ret.name = data['Name']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.hero_log_role_id) \
|
|
+ encode_str(self.name)
|
|
|
|
class HeroLogTrustRankData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.rank = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "HeroLogTrustRankData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.rank = data['HeroLogTrustRankId']
|
|
ret.total_exp = data['TotalExp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.rank) \
|
|
+ encode_int(self.total_exp)
|
|
|
|
class CharaData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.roma, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.gender = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.real_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CharaData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chara_id = data['CharaId']
|
|
ret.name = data['Name']
|
|
ret.roma = data['Roma']
|
|
ret.gender = data['Gender']
|
|
ret.real_name = data['RealName']
|
|
ret.comment = data['Comment']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.chara_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.roma) \
|
|
+ encode_short(self.gender) \
|
|
+ encode_str(self.real_name) \
|
|
+ encode_str(self.comment)
|
|
|
|
class CharaFriendlyRankData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.rank = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CharaFriendlyRankData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.rank = data['CharaFriendlyRankId']
|
|
ret.total_exp = data['TotalExp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.rank) \
|
|
+ encode_int(self.total_exp)
|
|
|
|
class EquipmentData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.equipment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.equipment_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.weapon_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rarity = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.prefab, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.power = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_increment = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_condition = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sale_price = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.composition_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_display_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_empty_frame_display_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EquipmentData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.equipment_id = data['EquipmentId']
|
|
ret.equipment_type = data['EquipmentType']
|
|
ret.weapon_type_id = data['WeaponTypeId']
|
|
ret.name = data['Name']
|
|
ret.rarity = data['Rarity']
|
|
ret.prefab = data['Prefab']
|
|
ret.power = data['Power']
|
|
ret.strength_increment = data['StrengthIncrement']
|
|
ret.skill_condition = data['SkillCondition']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
ret.sale_price = data['SalePrice']
|
|
ret.composition_exp = data['CompositionExp']
|
|
ret.awakening_exp = data['AwakeningExp']
|
|
ret.flavor_text = data['FlavorText']
|
|
ret.collection_display_start_date = data['CollectionDisplayStartDate']
|
|
ret.collection_empty_frame_display_flag = data['CollectionEmptyFrameDisplayFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.equipment_id) \
|
|
+ encode_byte(self.equipment_type) \
|
|
+ encode_short(self.weapon_type_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_byte(self.rarity) \
|
|
+ encode_str(self.prefab) \
|
|
+ encode_int(self.power) \
|
|
+ encode_int(self.strength_increment) \
|
|
+ encode_short(self.skill_condition) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2) \
|
|
+ encode_int(self.sale_price) \
|
|
+ encode_int(self.composition_exp) \
|
|
+ encode_int(self.awakening_exp) \
|
|
+ encode_str(self.flavor_text) \
|
|
+ encode_date_str(self.collection_display_start_date) \
|
|
+ encode_byte(self.collection_empty_frame_display_flag)
|
|
|
|
class EquipmentLevelData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.require_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.total_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EquipmentLevelData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.level = data['EquipmentLevelId']
|
|
ret.require_exp = data['RequireExp']
|
|
ret.total_exp = data['TotalExp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.level) \
|
|
+ encode_int(self.require_exp) \
|
|
+ encode_int(self.total_exp)
|
|
|
|
class WeaponTypeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.weapon_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.action_behaviour, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sound_behaviour, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.physics_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.main_equip = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equip1 = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equip2 = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "WeaponTypeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.weapon_type_id = data['WeaponTypeId']
|
|
ret.name = data['Name']
|
|
ret.action_behaviour = data['ActionBehaviour']
|
|
ret.sound_behaviour = data['SoundBehaviour']
|
|
ret.physics_attr = data['PhysicsAttr']
|
|
ret.main_equip = data['MainEquip']
|
|
ret.sub_equip1 = data['SubEquip1']
|
|
ret.sub_equip2 = data['SubEquip2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.weapon_type_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.action_behaviour) \
|
|
+ encode_str(self.sound_behaviour) \
|
|
+ encode_short(self.physics_attr) \
|
|
+ encode_short(self.main_equip) \
|
|
+ encode_short(self.sub_equip1) \
|
|
+ encode_short(self.sub_equip2)
|
|
|
|
class ItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.item_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rarity = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.value = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_value1_min, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.property_value1_max, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.property_value2_min, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.property_value2_max, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sale_price = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.item_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.item_id = data['ItemId']
|
|
ret.item_type = data['ItemTypeId']
|
|
ret.name = data['Name']
|
|
ret.rarity = data['Rarity']
|
|
ret.value = data['Value']
|
|
ret.property_id = data['PropertyId']
|
|
ret.property_value1_min = data['PropertyValue1Min']
|
|
ret.property_value1_max = data['PropertyValue1Max']
|
|
ret.property_value2_min = data['PropertyValue2Min']
|
|
ret.property_value2_max = data['PropertyValue2Max']
|
|
ret.flavor_text = data['FlavorText']
|
|
ret.sale_price = data['SalePrice']
|
|
ret.item_icon = data['ItemIcon']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.item_id) \
|
|
+ encode_int(self.item_type) \
|
|
+ encode_str(self.name) \
|
|
+ encode_byte(self.rarity) \
|
|
+ encode_int(self.value) \
|
|
+ encode_int(self.property_id) \
|
|
+ encode_str(self.property_value1_min) \
|
|
+ encode_str(self.property_value1_max) \
|
|
+ encode_str(self.property_value2_min) \
|
|
+ encode_str(self.property_value2_max) \
|
|
+ encode_str(self.flavor_text) \
|
|
+ encode_int(self.sale_price) \
|
|
+ encode_str(self.item_icon)
|
|
|
|
class ItemTypeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.item_type_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.item_type_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ItemTypeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.item_type_id = data['ItemTypeId']
|
|
ret.item_type_name = data['ItemTypeName']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.item_type_id) \
|
|
+ encode_str(self.item_type_name)
|
|
|
|
class BuffItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.buff_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BuffItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.buff_item_id = data['BuffItemId']
|
|
ret.name = data['Name']
|
|
ret.flavor_text = data['FlavorText']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.buff_item_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.flavor_text)
|
|
|
|
class EnemyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.enemy_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EnemyData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.enemy_id = data['EnemyId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.name = data['Name']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.enemy_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_str(self.name)
|
|
|
|
class EnemySetData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.enemy_set_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.enemy_set_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.enemy_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.enemy_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EnemySetData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.enemy_set_id = data['EnemySetId']
|
|
ret.enemy_set_sub_id = data['EnemySetSubId']
|
|
ret.enemy_id = data['EnemyId']
|
|
ret.enemy_num = data['EnemyNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.enemy_set_id) \
|
|
+ encode_int(self.enemy_set_sub_id) \
|
|
+ encode_int(self.enemy_id) \
|
|
+ encode_short(self.enemy_num)
|
|
|
|
class EnemyKindData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.enemy_kind_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.enemy_category_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.icon_filepath, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weak_physics_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.weak_magic_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.weak_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.resist_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_display_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_empty_frame_display_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EnemyKindData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.enemy_kind_id = data['EnemyKindId']
|
|
ret.enemy_category_id = data['EnemyCategoryId']
|
|
ret.name = data['Name']
|
|
ret.icon_filepath = data['IconFilepath']
|
|
ret.weak_physics_attr = data['WeakPhysicsAttr']
|
|
ret.weak_magic_attr = data['WeakMagicAttr']
|
|
ret.weak_text = data['WeakText']
|
|
ret.resist_text = data['ResistText']
|
|
ret.flavor_text = data['FlavorText']
|
|
ret.collection_display_start_date = data['CollectionDisplayStartDate']
|
|
ret.collection_empty_frame_display_flag = data['CollectionEmptyFrameDisplayFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.enemy_kind_id) \
|
|
+ encode_short(self.enemy_category_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.icon_filepath) \
|
|
+ encode_short(self.weak_physics_attr) \
|
|
+ encode_short(self.weak_magic_attr) \
|
|
+ encode_str(self.weak_text) \
|
|
+ encode_str(self.resist_text) \
|
|
+ encode_str(self.flavor_text) \
|
|
+ encode_date_str(self.collection_display_start_date) \
|
|
+ encode_byte(self.collection_empty_frame_display_flag)
|
|
|
|
class EnemyCategoryData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.enemy_category_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.detail_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EnemyCategoryData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.enemy_category_id = data['EnemyCategoryId']
|
|
ret.name = data['Name']
|
|
ret.detail_text = data['DetailText']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.enemy_category_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.detail_text)
|
|
|
|
class UnitData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.prefab, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.animator, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.collision, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.radius, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.child_unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.stage_start_prefab, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.stage_start_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.stage_start_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.stage_touch_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.stage_touch_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.playable = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.monster = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.gimmick = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.anger = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.commander = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.isolated = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.base_behaviour, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sound_behaviour, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weapon_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.poison_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.paralysis_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sealed_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.question_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.blue_rose_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.charm_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.burning_time_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.invalid_quake = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.guard_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.just_guard_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flip_hp = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.down_hp = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.flip_recover_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.down_recover_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.down_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.loss_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.loss_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.move_speed, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.move_speed_angry, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rot_speed, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rot_speed_angry, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.range_min, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.range_max, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.range_min_angry, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.range_max_angry, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.back_step_speed, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.back_step_speed_angry, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.back_step_cool_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.monster_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.monster_type_angry = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.vs_boss_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.boss_camera_height, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.boss_camera_near_distance, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.boss_camera_far_distance, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.boss_camera_near_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.boss_camera_far_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.search_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.search_angle, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.lost_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.home_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.roar_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.auto_attack_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.auto_attack_interval, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.find_priority = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.find_range_min = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.find_range_max = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.leave_range = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.show_arrow = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.find_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.leave_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.defeat_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.warfare_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.angry_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bad_state_bone, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bad_state_offset_x, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bad_state_offset_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bad_state_offset_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.drop_offset_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.col_drop_percentage, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.col_drop_amount = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.vp_drop_percentage, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.vp_drop_amount = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.enemy_kind_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "UnitData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.unit_id = data['UnitId']
|
|
ret.name = data['Name']
|
|
ret.prefab = data['Prefab']
|
|
ret.animator = data['Animator']
|
|
ret.collision = data['Collision']
|
|
ret.radius = data['Radius']
|
|
ret.child_unit_id = data['ChildUnitId']
|
|
ret.stage_start_prefab = data['StageStartPrefab']
|
|
ret.stage_start_y = data['StageStartY']
|
|
ret.stage_start_z = data['StageStartZ']
|
|
ret.stage_touch_y = data['StageTouchY']
|
|
ret.stage_touch_z = data['StageTouchZ']
|
|
ret.playable = data['Playable']
|
|
ret.monster = data['Monster']
|
|
ret.gimmick = data['Gimmick']
|
|
ret.anger = data['Anger']
|
|
ret.commander = data['Commander']
|
|
ret.isolated = data['Isolated']
|
|
ret.base_behaviour = data['BaseBehaviour']
|
|
ret.sound_behaviour = data['SoundBehaviour']
|
|
ret.weapon_type = data['WeaponType']
|
|
ret.poison_time_coef = data['PoisonTimeCoef']
|
|
ret.paralysis_time_coef = data['ParalysisTimeCoef']
|
|
ret.sealed_time_coef = data['SealedTimeCoef']
|
|
ret.question_time_coef = data['QuestionTimeCoef']
|
|
ret.blue_rose_time_coef = data['BlueRoseTimeCoef']
|
|
ret.charm_time_coef = data['CharmTimeCoef']
|
|
ret.burning_time_coef = data['BurningTimeCoef']
|
|
ret.invalid_quake = data['InvalidQuake']
|
|
ret.guard_coef = data['GuardCoef']
|
|
ret.just_guard_time = data['JustGuardTime']
|
|
ret.flip_hp = data['FlipHp']
|
|
ret.down_hp = data['DownHp']
|
|
ret.flip_recover_time = data['FlipRecoverTime']
|
|
ret.down_recover_time = data['DownRecoverTime']
|
|
ret.down_time = data['DownTime']
|
|
ret.loss_damage = data['LossDamage']
|
|
ret.loss_time = data['LossTime']
|
|
ret.move_speed = data['MoveSpeed']
|
|
ret.move_speed_angry = data['MoveSpeedAngry']
|
|
ret.rot_speed = data['RotSpeed']
|
|
ret.rot_speed_angry = data['RotSpeedAngry']
|
|
ret.range_min = data['RangeMin']
|
|
ret.range_max = data['RangeMax']
|
|
ret.range_min_angry = data['RangeMinAngry']
|
|
ret.range_max_angry = data['RangeMaxAngry']
|
|
ret.back_step_speed = data['BackStepSpeed']
|
|
ret.back_step_speed_angry = data['BackStepSpeedAngry']
|
|
ret.back_step_cool_time = data['BackStepCoolTime']
|
|
ret.monster_type = data['MonsterType']
|
|
ret.monster_type_angry = data['MonsterTypeAngry']
|
|
ret.vs_boss_type = data['VsBossType']
|
|
ret.boss_camera_height = data['BossCameraHeight']
|
|
ret.boss_camera_near_distance = data['BossCameraNearDistance']
|
|
ret.boss_camera_far_distance = data['BossCameraFarDistance']
|
|
ret.boss_camera_near_range = data['BossCameraNearRange']
|
|
ret.boss_camera_far_range = data['BossCameraFarRange']
|
|
ret.search_range = data['SearchRange']
|
|
ret.search_angle = data['SearchAngle']
|
|
ret.lost_range = data['LostRange']
|
|
ret.home_range = data['HomeRange']
|
|
ret.roar_id = data['RoarId']
|
|
ret.auto_attack_range = data['AutoAttackRange']
|
|
ret.auto_attack_interval = data['AutoAttackInterval']
|
|
ret.find_priority = data['FindPriority']
|
|
ret.find_range_min = data['FindRangeMin']
|
|
ret.find_range_max = data['FindRangeMax']
|
|
ret.leave_range = data['LeaveRange']
|
|
ret.show_arrow = data['ShowArrow']
|
|
ret.find_id = data['FindId']
|
|
ret.leave_id = data['LeaveId']
|
|
ret.defeat_id = data['DefeatId']
|
|
ret.warfare_id = data['WarfareId']
|
|
ret.angry_id = data['AngryId']
|
|
ret.bad_state_bone = data['BadStateBone']
|
|
ret.bad_state_offset_x = data['BadStateOffsetX']
|
|
ret.bad_state_offset_y = data['BadStateOffsetY']
|
|
ret.bad_state_offset_z = data['BadStateOffsetZ']
|
|
ret.drop_offset_y = data['DropOffsetY']
|
|
ret.col_drop_percentage = data['ColDropPercentage']
|
|
ret.col_drop_amount = data['ColDropAmount']
|
|
ret.vp_drop_percentage = data['VpDropPercentage']
|
|
ret.vp_drop_amount = data['VpDropAmount']
|
|
ret.enemy_kind_id = data['EnemyKindId']
|
|
ret.defrag_match_league_point = data['DefragMatchLeaguePoint']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.prefab) \
|
|
+ encode_str(self.animator) \
|
|
+ encode_str(self.collision) \
|
|
+ encode_str(self.radius) \
|
|
+ encode_int(self.child_unit_id) \
|
|
+ encode_str(self.stage_start_prefab) \
|
|
+ encode_str(self.stage_start_y) \
|
|
+ encode_str(self.stage_start_z) \
|
|
+ encode_str(self.stage_touch_y) \
|
|
+ encode_str(self.stage_touch_z) \
|
|
+ encode_byte(self.playable) \
|
|
+ encode_byte(self.monster) \
|
|
+ encode_byte(self.gimmick) \
|
|
+ encode_byte(self.anger) \
|
|
+ encode_byte(self.commander) \
|
|
+ encode_byte(self.isolated) \
|
|
+ encode_str(self.base_behaviour) \
|
|
+ encode_str(self.sound_behaviour) \
|
|
+ encode_int(self.weapon_type) \
|
|
+ encode_str(self.poison_time_coef) \
|
|
+ encode_str(self.paralysis_time_coef) \
|
|
+ encode_str(self.sealed_time_coef) \
|
|
+ encode_str(self.question_time_coef) \
|
|
+ encode_str(self.blue_rose_time_coef) \
|
|
+ encode_str(self.charm_time_coef) \
|
|
+ encode_str(self.burning_time_coef) \
|
|
+ encode_byte(self.invalid_quake) \
|
|
+ encode_str(self.guard_coef) \
|
|
+ encode_str(self.just_guard_time) \
|
|
+ encode_short(self.flip_hp) \
|
|
+ encode_short(self.down_hp) \
|
|
+ encode_str(self.flip_recover_time) \
|
|
+ encode_str(self.down_recover_time) \
|
|
+ encode_str(self.down_time) \
|
|
+ encode_short(self.loss_damage) \
|
|
+ encode_str(self.loss_time) \
|
|
+ encode_str(self.move_speed) \
|
|
+ encode_str(self.move_speed_angry) \
|
|
+ encode_str(self.rot_speed) \
|
|
+ encode_str(self.rot_speed_angry) \
|
|
+ encode_str(self.range_min) \
|
|
+ encode_str(self.range_max) \
|
|
+ encode_str(self.range_min_angry) \
|
|
+ encode_str(self.range_max_angry) \
|
|
+ encode_str(self.back_step_speed) \
|
|
+ encode_str(self.back_step_speed_angry) \
|
|
+ encode_str(self.back_step_cool_time) \
|
|
+ encode_short(self.monster_type) \
|
|
+ encode_short(self.monster_type_angry) \
|
|
+ encode_short(self.vs_boss_type) \
|
|
+ encode_str(self.boss_camera_height) \
|
|
+ encode_str(self.boss_camera_near_distance) \
|
|
+ encode_str(self.boss_camera_far_distance) \
|
|
+ encode_str(self.boss_camera_near_range) \
|
|
+ encode_str(self.boss_camera_far_range) \
|
|
+ encode_str(self.search_range) \
|
|
+ encode_str(self.search_angle) \
|
|
+ encode_str(self.lost_range) \
|
|
+ encode_str(self.home_range) \
|
|
+ encode_str(self.roar_id) \
|
|
+ encode_str(self.auto_attack_range) \
|
|
+ encode_str(self.auto_attack_interval) \
|
|
+ encode_short(self.find_priority) \
|
|
+ encode_short(self.find_range_min) \
|
|
+ encode_short(self.find_range_max) \
|
|
+ encode_short(self.leave_range) \
|
|
+ encode_byte(self.show_arrow) \
|
|
+ encode_str(self.find_id) \
|
|
+ encode_str(self.leave_id) \
|
|
+ encode_str(self.defeat_id) \
|
|
+ encode_str(self.warfare_id) \
|
|
+ encode_str(self.angry_id) \
|
|
+ encode_str(self.bad_state_bone) \
|
|
+ encode_str(self.bad_state_offset_x) \
|
|
+ encode_str(self.bad_state_offset_y) \
|
|
+ encode_str(self.bad_state_offset_z) \
|
|
+ encode_str(self.drop_offset_y) \
|
|
+ encode_str(self.col_drop_percentage) \
|
|
+ encode_short(self.col_drop_amount) \
|
|
+ encode_str(self.vp_drop_percentage) \
|
|
+ encode_short(self.vp_drop_amount) \
|
|
+ encode_int(self.enemy_kind_id) \
|
|
+ encode_int(self.defrag_match_league_point)
|
|
|
|
class UnitGimmickData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unit_gimmick_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.gimmick_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.crystal_grade = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.col = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.heal_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.gimmick_attack_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.interval, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.summon_count = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.effect, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.effect_bone, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.effect_x, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.effect_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.effect_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.ground_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state_idle, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state_reaction, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state_active, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state_break, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.time_sub_state_break, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "UnitGimmickData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.unit_gimmick_id = data['UnitGimmickId']
|
|
ret.name = data['Name']
|
|
ret.gimmick_type = data['GimmickType']
|
|
ret.range = data['Range']
|
|
ret.crystal_grade = data['CrystalGrade']
|
|
ret.col = data['Col']
|
|
ret.skill_exp = data['SkillExp']
|
|
ret.heal_rate = data['HealRate']
|
|
ret.gimmick_attack_id = data['GimmickAttackId']
|
|
ret.interval = data['Interval']
|
|
ret.summon_count = data['SummonCount']
|
|
ret.effect = data['Effect']
|
|
ret.effect_bone = data['EffectBone']
|
|
ret.effect_x = data['EffectX']
|
|
ret.effect_y = data['EffectY']
|
|
ret.effect_z = data['EffectZ']
|
|
ret.se = data['Se']
|
|
ret.ground_se = data['GroundSe']
|
|
ret.sub_state_idle = data['SubStateIdle']
|
|
ret.sub_state_reaction = data['SubStateReaction']
|
|
ret.sub_state_active = data['SubStateActive']
|
|
ret.sub_state_break = data['SubStateBreak']
|
|
ret.time_sub_state_break = data['TimeSubStateBreak']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unit_gimmick_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_int(self.gimmick_type) \
|
|
+ encode_str(self.range) \
|
|
+ encode_int(self.crystal_grade) \
|
|
+ encode_int(self.col) \
|
|
+ encode_int(self.skill_exp) \
|
|
+ encode_str(self.heal_rate) \
|
|
+ encode_short(self.gimmick_attack_id) \
|
|
+ encode_str(self.interval) \
|
|
+ encode_int(self.summon_count) \
|
|
+ encode_str(self.effect) \
|
|
+ encode_str(self.effect_bone) \
|
|
+ encode_str(self.effect_x) \
|
|
+ encode_str(self.effect_y) \
|
|
+ encode_str(self.effect_z) \
|
|
+ encode_str(self.se) \
|
|
+ encode_str(self.ground_se) \
|
|
+ encode_str(self.sub_state_idle) \
|
|
+ encode_str(self.sub_state_reaction) \
|
|
+ encode_str(self.sub_state_active) \
|
|
+ encode_str(self.sub_state_break) \
|
|
+ encode_str(self.time_sub_state_break)
|
|
|
|
class UnitCollisionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unit_collision_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.keyword, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bone, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.usually = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.angry = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.type_index = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.begin_x, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.begin_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.begin_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_x, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.radius, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.slash_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.strike_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.thrust_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.fire_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.water_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.air_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.earth_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.holy_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.dark_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.poison_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.paralysis_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sealed_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.question_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.blue_rose_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.charm_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.burning_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flip_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.down_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.knock_back_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "UnitCollisionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.unit_collision_id = data['UnitCollisionId']
|
|
ret.keyword = data['Keyword']
|
|
ret.name = data['Name']
|
|
ret.bone = data['Bone']
|
|
ret.usually = data['Usually']
|
|
ret.angry = data['Angry']
|
|
ret.type_index = data['TypeIndex']
|
|
ret.begin_x = data['BeginX']
|
|
ret.begin_y = data['BeginY']
|
|
ret.begin_z = data['BeginZ']
|
|
ret.end_x = data['EndX']
|
|
ret.end_y = data['EndY']
|
|
ret.end_z = data['EndZ']
|
|
ret.radius = data['Radius']
|
|
ret.slash_coef = data['SlashCoef']
|
|
ret.strike_coef = data['StrikeCoef']
|
|
ret.thrust_coef = data['ThrustCoef']
|
|
ret.fire_coef = data['FireCoef']
|
|
ret.water_coef = data['WaterCoef']
|
|
ret.air_coef = data['AirCoef']
|
|
ret.earth_coef = data['EarthCoef']
|
|
ret.holy_coef = data['HolyCoef']
|
|
ret.dark_coef = data['DarkCoef']
|
|
ret.poison_coef = data['PoisonCoef']
|
|
ret.paralysis_coef = data['ParalysisCoef']
|
|
ret.sealed_coef = data['SealedCoef']
|
|
ret.question_coef = data['QuestionCoef']
|
|
ret.blue_rose_coef = data['BlueRoseCoef']
|
|
ret.charm_coef = data['CharmCoef']
|
|
ret.burning_coef = data['BurningCoef']
|
|
ret.flip_coef = data['FlipCoef']
|
|
ret.down_coef = data['DownCoef']
|
|
ret.knock_back_coef = data['KnockBackCoef']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unit_collision_id) \
|
|
+ encode_str(self.keyword) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.bone) \
|
|
+ encode_byte(self.usually) \
|
|
+ encode_byte(self.angry) \
|
|
+ encode_short(self.type_index) \
|
|
+ encode_str(self.begin_x) \
|
|
+ encode_str(self.begin_y) \
|
|
+ encode_str(self.begin_z) \
|
|
+ encode_str(self.end_x) \
|
|
+ encode_str(self.end_y) \
|
|
+ encode_str(self.end_z) \
|
|
+ encode_str(self.radius) \
|
|
+ encode_str(self.slash_coef) \
|
|
+ encode_str(self.strike_coef) \
|
|
+ encode_str(self.thrust_coef) \
|
|
+ encode_str(self.fire_coef) \
|
|
+ encode_str(self.water_coef) \
|
|
+ encode_str(self.air_coef) \
|
|
+ encode_str(self.earth_coef) \
|
|
+ encode_str(self.holy_coef) \
|
|
+ encode_str(self.dark_coef) \
|
|
+ encode_str(self.poison_coef) \
|
|
+ encode_str(self.paralysis_coef) \
|
|
+ encode_str(self.sealed_coef) \
|
|
+ encode_str(self.question_coef) \
|
|
+ encode_str(self.blue_rose_coef) \
|
|
+ encode_str(self.charm_coef) \
|
|
+ encode_str(self.burning_coef) \
|
|
+ encode_str(self.flip_coef) \
|
|
+ encode_str(self.down_coef) \
|
|
+ encode_str(self.knock_back_coef)
|
|
|
|
class UnitPowerData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.unit_power_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.lv = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.param_hp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.param_str = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.param_vit = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.param_int = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "UnitPowerData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.unit_power_id = data['UnitPowerId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.lv = data['Lv']
|
|
ret.param_hp = data['ParamHp']
|
|
ret.param_str = data['ParamStr']
|
|
ret.param_vit = data['ParamVit']
|
|
ret.param_int = data['ParamInt']
|
|
ret.exp = data['Exp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.unit_power_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.lv) \
|
|
+ encode_int(self.param_hp) \
|
|
+ encode_int(self.param_str) \
|
|
+ encode_int(self.param_vit) \
|
|
+ encode_int(self.param_int) \
|
|
+ encode_int(self.exp)
|
|
|
|
class GimmickAttackData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gimmick_attack_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.hit_enemy = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.hit_friend = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.attack_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.heal_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flip_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.down_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.poison_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.paralysis_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sealed_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.question_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.blue_rose_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.charm_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.burning_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.knock_back, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.knock_back_g, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.forward_knock_back = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.break_interval, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.attack_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.physics_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.magic_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hit_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weak_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.resist_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GimmickAttackData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gimmick_attack_id = data['GimmickAttackId']
|
|
ret.name = data['Name']
|
|
ret.hit_enemy = data['HitEnemy']
|
|
ret.hit_friend = data['HitFriend']
|
|
ret.attack_coef = data['AttackCoef']
|
|
ret.heal_coef = data['HealCoef']
|
|
ret.flip_damage = data['FlipDamage']
|
|
ret.down_damage = data['DownDamage']
|
|
ret.poison_incidence = data['PoisonIncidence']
|
|
ret.paralysis_incidence = data['ParalysisIncidence']
|
|
ret.sealed_incidence = data['SealedIncidence']
|
|
ret.question_incidence = data['QuestionIncidence']
|
|
ret.blue_rose_incidence = data['BlueRoseIncidence']
|
|
ret.charm_incidence = data['CharmIncidence']
|
|
ret.burning_incidence = data['BurningIncidence']
|
|
ret.knock_back = data['KnockBack']
|
|
ret.knock_back_g = data['KnockBackG']
|
|
ret.forward_knock_back = data['ForwardKnockBack']
|
|
ret.break_interval = data['BreakInterval']
|
|
ret.attack_type = data['AttackType']
|
|
ret.physics_attr = data['PhysicsAttr']
|
|
ret.magic_attr = data['MagicAttr']
|
|
ret.hit_se = data['HitSe']
|
|
ret.weak_se = data['WeakSe']
|
|
ret.resist_se = data['ResistSe']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.gimmick_attack_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_byte(self.hit_enemy) \
|
|
+ encode_byte(self.hit_friend) \
|
|
+ encode_str(self.attack_coef) \
|
|
+ encode_str(self.heal_coef) \
|
|
+ encode_short(self.flip_damage) \
|
|
+ encode_short(self.down_damage) \
|
|
+ encode_str(self.poison_incidence) \
|
|
+ encode_str(self.paralysis_incidence) \
|
|
+ encode_str(self.sealed_incidence) \
|
|
+ encode_str(self.question_incidence) \
|
|
+ encode_str(self.blue_rose_incidence) \
|
|
+ encode_str(self.charm_incidence) \
|
|
+ encode_str(self.burning_incidence) \
|
|
+ encode_str(self.knock_back) \
|
|
+ encode_str(self.knock_back_g) \
|
|
+ encode_byte(self.forward_knock_back) \
|
|
+ encode_str(self.break_interval) \
|
|
+ encode_short(self.attack_type) \
|
|
+ encode_short(self.physics_attr) \
|
|
+ encode_short(self.magic_attr) \
|
|
+ encode_str(self.hit_se) \
|
|
+ encode_str(self.weak_se) \
|
|
+ encode_str(self.resist_se)
|
|
|
|
class CharaAttackData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chara_attack_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.attack_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flip_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.down_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.poison_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.paralysis_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sealed_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.question_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.blue_rose_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.charm_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.knock_back, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.forward_knock_back = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.break_interval, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weapon_slot = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.attack_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.physics_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.magic_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.spell_blast = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.hit_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weak_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.resist_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CharaAttackData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chara_attack_id = data['CharaAttackId']
|
|
ret.name = data['Name']
|
|
ret.attack_coef = data['AttackCoef']
|
|
ret.flip_damage = data['FlipDamage']
|
|
ret.down_damage = data['DownDamage']
|
|
ret.poison_incidence = data['PoisonIncidence']
|
|
ret.paralysis_incidence = data['ParalysisIncidence']
|
|
ret.sealed_incidence = data['SealedIncidence']
|
|
ret.question_incidence = data['QuestionIncidence']
|
|
ret.blue_rose_incidence = data['BlueRoseIncidence']
|
|
ret.charm_incidence = data['CharmIncidence']
|
|
ret.knock_back = data['KnockBack']
|
|
ret.forward_knock_back = data['ForwardKnockBack']
|
|
ret.break_interval = data['BreakInterval']
|
|
ret.weapon_slot = data['WeaponSlot']
|
|
ret.attack_type = data['AttackType']
|
|
ret.physics_attr = data['PhysicsAttr']
|
|
ret.magic_attr = data['MagicAttr']
|
|
ret.spell_blast = data['SpellBlast']
|
|
ret.hit_se = data['HitSe']
|
|
ret.weak_se = data['WeakSe']
|
|
ret.resist_se = data['ResistSe']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.chara_attack_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.attack_coef) \
|
|
+ encode_short(self.flip_damage) \
|
|
+ encode_short(self.down_damage) \
|
|
+ encode_str(self.poison_incidence) \
|
|
+ encode_str(self.paralysis_incidence) \
|
|
+ encode_str(self.sealed_incidence) \
|
|
+ encode_str(self.question_incidence) \
|
|
+ encode_str(self.blue_rose_incidence) \
|
|
+ encode_str(self.charm_incidence) \
|
|
+ encode_str(self.knock_back) \
|
|
+ encode_byte(self.forward_knock_back) \
|
|
+ encode_str(self.break_interval) \
|
|
+ encode_short(self.weapon_slot) \
|
|
+ encode_short(self.attack_type) \
|
|
+ encode_short(self.physics_attr) \
|
|
+ encode_short(self.magic_attr) \
|
|
+ encode_byte(self.spell_blast) \
|
|
+ encode_str(self.hit_se) \
|
|
+ encode_str(self.weak_se) \
|
|
+ encode_str(self.resist_se)
|
|
|
|
class BossAttackData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.boss_attack_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.attack_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flip_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.down_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.poison_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sealed_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.question_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.reduce_max_hp_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.burning_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quake = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.can_parry = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.knock_back, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.knock_back_g, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.forward_knock_back = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.attack_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.physics_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.magic_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.spell_blast = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.hit_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weak_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.resist_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BossAttackData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.boss_attack_id = data['BossAttackId']
|
|
ret.name = data['Name']
|
|
ret.attack_coef = data['AttackCoef']
|
|
ret.flip_damage = data['FlipDamage']
|
|
ret.down_damage = data['DownDamage']
|
|
ret.poison_incidence = data['PoisonIncidence']
|
|
ret.sealed_incidence = data['SealedIncidence']
|
|
ret.question_incidence = data['QuestionIncidence']
|
|
ret.reduce_max_hp_incidence = data['ReduceMaxHpIncidence']
|
|
ret.burning_incidence = data['BurningIncidence']
|
|
ret.quake = data['Quake']
|
|
ret.can_parry = data['CanParry']
|
|
ret.knock_back = data['KnockBack']
|
|
ret.knock_back_g = data['KnockBackG']
|
|
ret.forward_knock_back = data['ForwardKnockBack']
|
|
ret.attack_type = data['AttackType']
|
|
ret.physics_attr = data['PhysicsAttr']
|
|
ret.magic_attr = data['MagicAttr']
|
|
ret.spell_blast = data['SpellBlast']
|
|
ret.hit_se = data['HitSe']
|
|
ret.weak_se = data['WeakSe']
|
|
ret.resist_se = data['ResistSe']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.boss_attack_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.attack_coef) \
|
|
+ encode_short(self.flip_damage) \
|
|
+ encode_short(self.down_damage) \
|
|
+ encode_str(self.poison_incidence) \
|
|
+ encode_str(self.sealed_incidence) \
|
|
+ encode_str(self.question_incidence) \
|
|
+ encode_str(self.reduce_max_hp_incidence) \
|
|
+ encode_str(self.burning_incidence) \
|
|
+ encode_byte(self.quake) \
|
|
+ encode_byte(self.can_parry) \
|
|
+ encode_str(self.knock_back) \
|
|
+ encode_str(self.knock_back_g) \
|
|
+ encode_byte(self.forward_knock_back) \
|
|
+ encode_short(self.attack_type) \
|
|
+ encode_short(self.physics_attr) \
|
|
+ encode_short(self.magic_attr) \
|
|
+ encode_byte(self.spell_blast) \
|
|
+ encode_str(self.hit_se) \
|
|
+ encode_str(self.weak_se) \
|
|
+ encode_str(self.resist_se)
|
|
|
|
class MonsterAttackData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.monster_attack_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.attack_coef, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flip_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.down_damage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.poison_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sealed_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.question_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.reduce_max_hp_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.burning_incidence, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quake = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.can_parry = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.knock_back, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.knock_back_g, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.forward_knock_back = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.attack_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.physics_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.magic_attr = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.spell_blast = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.hit_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.weak_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.resist_se, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "MonsterAttackData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.monster_attack_id = data['MonsterAttackId']
|
|
ret.name = data['Name']
|
|
ret.attack_coef = data['AttackCoef']
|
|
ret.flip_damage = data['FlipDamage']
|
|
ret.down_damage = data['DownDamage']
|
|
ret.poison_incidence = data['PoisonIncidence']
|
|
ret.sealed_incidence = data['SealedIncidence']
|
|
ret.question_incidence = data['QuestionIncidence']
|
|
ret.reduce_max_hp_incidence = data['ReduceMaxHpIncidence']
|
|
ret.burning_incidence = data['BurningIncidence']
|
|
ret.quake = data['Quake']
|
|
ret.can_parry = data['CanParry']
|
|
ret.knock_back = data['KnockBack']
|
|
ret.knock_back_g = data['KnockBackG']
|
|
ret.forward_knock_back = data['ForwardKnockBack']
|
|
ret.attack_type = data['AttackType']
|
|
ret.physics_attr = data['PhysicsAttr']
|
|
ret.magic_attr = data['MagicAttr']
|
|
ret.spell_blast = data['SpellBlast']
|
|
ret.hit_se = data['HitSe']
|
|
ret.weak_se = data['WeakSe']
|
|
ret.resist_se = data['ResistSe']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.monster_attack_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.attack_coef) \
|
|
+ encode_short(self.flip_damage) \
|
|
+ encode_short(self.down_damage) \
|
|
+ encode_str(self.poison_incidence) \
|
|
+ encode_str(self.sealed_incidence) \
|
|
+ encode_str(self.question_incidence) \
|
|
+ encode_str(self.reduce_max_hp_incidence) \
|
|
+ encode_str(self.burning_incidence) \
|
|
+ encode_byte(self.quake) \
|
|
+ encode_byte(self.can_parry) \
|
|
+ encode_str(self.knock_back) \
|
|
+ encode_str(self.knock_back_g) \
|
|
+ encode_byte(self.forward_knock_back) \
|
|
+ encode_short(self.attack_type) \
|
|
+ encode_short(self.physics_attr) \
|
|
+ encode_short(self.magic_attr) \
|
|
+ encode_byte(self.spell_blast) \
|
|
+ encode_str(self.hit_se) \
|
|
+ encode_str(self.weak_se) \
|
|
+ encode_str(self.resist_se)
|
|
|
|
class MonsterActionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.monster_action_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.slot = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.usable_lv = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_count = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.not_angry = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.is_angry = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.can_sealed = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.multi_play_only = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.angle_min, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.angle_max, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.range_min, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.range_max, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.attack_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.delay_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cool_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "MonsterActionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.monster_action_id = data['MonsterActionId']
|
|
ret.name = data['Name']
|
|
ret.unit_id = data['UnitId']
|
|
ret.slot = data['Slot']
|
|
ret.usable_lv = data['UsableLv']
|
|
ret.use_count = data['UseCount']
|
|
ret.not_angry = data['NotAngry']
|
|
ret.is_angry = data['IsAngry']
|
|
ret.can_sealed = data['CanSealed']
|
|
ret.multi_play_only = data['MultiPlayOnly']
|
|
ret.angle_min = data['AngleMin']
|
|
ret.angle_max = data['AngleMax']
|
|
ret.range_min = data['RangeMin']
|
|
ret.range_max = data['RangeMax']
|
|
ret.attack_time = data['AttackTime']
|
|
ret.delay_time = data['DelayTime']
|
|
ret.cool_time = data['CoolTime']
|
|
ret.state = data['State']
|
|
ret.sub_state = data['SubState']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.monster_action_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.slot) \
|
|
+ encode_int(self.usable_lv) \
|
|
+ encode_int(self.use_count) \
|
|
+ encode_byte(self.not_angry) \
|
|
+ encode_byte(self.is_angry) \
|
|
+ encode_byte(self.can_sealed) \
|
|
+ encode_byte(self.multi_play_only) \
|
|
+ encode_str(self.angle_min) \
|
|
+ encode_str(self.angle_max) \
|
|
+ encode_str(self.range_min) \
|
|
+ encode_str(self.range_max) \
|
|
+ encode_str(self.attack_time) \
|
|
+ encode_str(self.delay_time) \
|
|
+ encode_str(self.cool_time) \
|
|
+ encode_str(self.state) \
|
|
+ encode_str(self.sub_state)
|
|
|
|
class PropertyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_target_type = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.property_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.property_name_format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.property_type_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value1_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value1_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value2_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value2_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PropertyData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.property_id = data['PropertyId']
|
|
ret.property_target_type = data['PropertyTargetType']
|
|
ret.property_name = data['PropertyName']
|
|
ret.property_name_format = data['PropertyNameFormat']
|
|
ret.property_type_id = data['PropertyTypeId']
|
|
ret.value1_min = data['Value1Min']
|
|
ret.value1_max = data['Value1Max']
|
|
ret.value2_min = data['Value2Min']
|
|
ret.value2_max = data['Value2Max']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.property_id) \
|
|
+ encode_short(self.property_target_type) \
|
|
+ encode_str(self.property_name) \
|
|
+ encode_str(self.property_name_format) \
|
|
+ encode_int(self.property_type_id) \
|
|
+ encode_int(self.value1_min) \
|
|
+ encode_int(self.value1_max) \
|
|
+ encode_int(self.value2_min) \
|
|
+ encode_int(self.value2_max)
|
|
|
|
class PropertyTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.property_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value1_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value1_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value2_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value2_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PropertyTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.property_table_id = data['PropertyTableId']
|
|
ret.property_table_sub_id = data['PropertyTableSubId']
|
|
ret.property_id = data['PropertyId']
|
|
ret.value1_min = data['Value1Min']
|
|
ret.value1_max = data['Value1Max']
|
|
ret.value2_min = data['Value2Min']
|
|
ret.value2_max = data['Value2Max']
|
|
ret.rate = data['Rate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.property_table_id) \
|
|
+ encode_int(self.property_table_sub_id) \
|
|
+ encode_int(self.property_id) \
|
|
+ encode_int(self.value1_min) \
|
|
+ encode_int(self.value1_max) \
|
|
+ encode_int(self.value2_min) \
|
|
+ encode_int(self.value2_max) \
|
|
+ encode_int(self.rate)
|
|
|
|
class PropertyTypeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.property_type_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_type_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.physics_attr = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.magic_attr = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.permission_same_id_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.auto_equip_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PropertyTypeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.property_type_id = data['PropertyTypeId']
|
|
ret.property_type_name = data['PropertyTypeName']
|
|
ret.physics_attr = data['PhysicsAttr']
|
|
ret.magic_attr = data['MagicAttr']
|
|
ret.permission_same_id_flag = data['PermissionSameIdFlag']
|
|
ret.auto_equip_flag = data['AutoEquipFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.property_type_id) \
|
|
+ encode_str(self.property_type_name) \
|
|
+ encode_int(self.physics_attr) \
|
|
+ encode_int(self.magic_attr) \
|
|
+ encode_byte(self.permission_same_id_flag) \
|
|
+ encode_byte(self.auto_equip_flag)
|
|
|
|
class SkillData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.weapon_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.attack = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.passive = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.pet = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_condition = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.cool_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sword_color_r, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sword_color_g, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sword_color_b, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.motion_index = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.skill_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.friend_skill_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.info_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SkillData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.skill_id = data['SkillId']
|
|
ret.weapon_type_id = data['WeaponTypeId']
|
|
ret.name = data['Name']
|
|
ret.attack = data['Attack']
|
|
ret.passive = data['Passive']
|
|
ret.pet = data['Pet']
|
|
ret.level = data['Level']
|
|
ret.skill_condition = data['SkillCondition']
|
|
ret.cool_time = data['CoolTime']
|
|
ret.sword_color_r = data['SwordColorR']
|
|
ret.sword_color_g = data['SwordColorG']
|
|
ret.sword_color_b = data['SwordColorB']
|
|
ret.motion_index = data['MotionIndex']
|
|
ret.state = data['State']
|
|
ret.sub_state = data['SubState']
|
|
ret.skill_icon = data['SkillIcon']
|
|
ret.friend_skill_icon = data['FriendSkillIcon']
|
|
ret.info_text = data['InfoText']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.skill_id) \
|
|
+ encode_short(self.weapon_type_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_byte(self.attack) \
|
|
+ encode_byte(self.passive) \
|
|
+ encode_byte(self.pet) \
|
|
+ encode_short(self.level) \
|
|
+ encode_short(self.skill_condition) \
|
|
+ encode_str(self.cool_time) \
|
|
+ encode_str(self.sword_color_r) \
|
|
+ encode_str(self.sword_color_g) \
|
|
+ encode_str(self.sword_color_b) \
|
|
+ encode_short(self.motion_index) \
|
|
+ encode_str(self.state) \
|
|
+ encode_str(self.sub_state) \
|
|
+ encode_str(self.skill_icon) \
|
|
+ encode_str(self.friend_skill_icon) \
|
|
+ encode_str(self.info_text)
|
|
|
|
class SkillTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.skill_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.level = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SkillTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.skill_table_id = data['SkillTableId']
|
|
ret.skill_table_sub_id = data['SkillTableSubId']
|
|
ret.level = data['Level']
|
|
ret.awakening_id = data['AwakeningId']
|
|
ret.skill_id = data['SkillId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.skill_table_id) \
|
|
+ encode_int(self.skill_table_sub_id) \
|
|
+ encode_int(self.level) \
|
|
+ encode_int(self.awakening_id) \
|
|
+ encode_int(self.skill_id)
|
|
|
|
class SkillLevelData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.skill_level_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.exp_total = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SkillLevelData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.skill_level_id = data['SkillLevelId']
|
|
ret.exp = data['Exp']
|
|
ret.exp_total = data['ExpTotal']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.skill_level_id) \
|
|
+ encode_int(self.exp) \
|
|
+ encode_int(self.exp_total)
|
|
|
|
class AwakeningData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.awakening_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.total_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.bonus_hero_log, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bonus_weapon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bonus_armor, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AwakeningData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.awakening_id = data['AwakeningId']
|
|
ret.total_exp = data['TotalExp']
|
|
ret.bonus_hero_log = data['BonusHeroLog']
|
|
ret.bonus_weapon = data['BonusWeapon']
|
|
ret.bonus_armor = data['BonusArmor']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.awakening_id) \
|
|
+ encode_int(self.total_exp) \
|
|
+ encode_str(self.bonus_hero_log) \
|
|
+ encode_str(self.bonus_weapon) \
|
|
+ encode_str(self.bonus_armor)
|
|
|
|
class SynchroSkillData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.synchro_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.name_in_skill_cutin, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sub_state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.icon_file_path, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.info_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.se_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.voice_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.delay_time = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SynchroSkillData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.synchro_skill_id = data['SynchroSkillId']
|
|
ret.name = data['Name']
|
|
ret.name_in_skill_cutin = data['NameInSkillCutin']
|
|
ret.sub_state = data['SubState']
|
|
ret.chara_id = data['CharaId']
|
|
ret.icon_file_path = data['IconFilePath']
|
|
ret.info_text = data['InfoText']
|
|
ret.se_name = data['SeName']
|
|
ret.voice_id = data['VoiceId']
|
|
ret.delay_time = data['DelayTime']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.synchro_skill_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.name_in_skill_cutin) \
|
|
+ encode_str(self.sub_state) \
|
|
+ encode_short(self.chara_id) \
|
|
+ encode_str(self.icon_file_path) \
|
|
+ encode_str(self.info_text) \
|
|
+ encode_str(self.se_name) \
|
|
+ encode_str(self.voice_id) \
|
|
+ encode_int(self.delay_time)
|
|
|
|
class SoundSkillCutInVoiceData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.sound_skill_cut_in_voice_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.record_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.que_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.delay_time = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SoundSkillCutInVoiceData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.sound_skill_cut_in_voice_id = data['SoundSkillCutInVoiceId']
|
|
ret.skill_id = data['SkillId']
|
|
ret.chara_id = data['CharaId']
|
|
ret.record_id = data['RecordId']
|
|
ret.que_name = data['QueName']
|
|
ret.delay_time = data['DelayTime']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.sound_skill_cut_in_voice_id) \
|
|
+ encode_int(self.skill_id) \
|
|
+ encode_int(self.chara_id) \
|
|
+ encode_str(self.record_id) \
|
|
+ encode_str(self.que_name) \
|
|
+ encode_int(self.delay_time)
|
|
|
|
class QuestSceneData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_scene_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sort_no = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.map_data, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unit_data, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.demo_map, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bgm_basic, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.bgm_boss, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.tutorial = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.chara_comment_id_0 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_comment_id_1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_comment_id_2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_comment_id_3 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_comment_id_4 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.col_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.limit_default = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.limit_time_dec, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.limit_chara_dec, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.limit_resurrection = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mission_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mission_enemy_lv_limit = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.reward_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.player_trace_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.success_player_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.failed_player_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.greed_spawn_wait_count = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.honey_spawn_wait_count = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.menu_display_enemy_set_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.stage_filepath, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rarity_up_chance_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_mob_hp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_mob_atk_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_leader_hp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_leader_atk_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_boss_hp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_boss_atk_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.pair_exp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_mob_hp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_mob_atk_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_leader_hp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_leader_atk_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_boss_hp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_boss_atk_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trio_exp_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.single_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.pair_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.trio_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSceneData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.sort_no = data['SortNo']
|
|
ret.name = data['Name']
|
|
ret.map_data = data['MapData']
|
|
ret.unit_data = data['UnitData']
|
|
ret.demo_map = data['DemoMap']
|
|
ret.bgm_basic = data['BgmBasic']
|
|
ret.bgm_boss = data['BgmBoss']
|
|
ret.tutorial = data['Tutorial']
|
|
ret.chara_comment_id_0 = data['CharaCommentId0']
|
|
ret.chara_comment_id_1 = data['CharaCommentId1']
|
|
ret.chara_comment_id_2 = data['CharaCommentId2']
|
|
ret.chara_comment_id_3 = data['CharaCommentId3']
|
|
ret.chara_comment_id_4 = data['CharaCommentId4']
|
|
ret.col_rate = data['ColRate']
|
|
ret.limit_default = data['LimitDefault']
|
|
ret.limit_time_dec = data['LimitTimeDec']
|
|
ret.limit_chara_dec = data['LimitCharaDec']
|
|
ret.limit_resurrection = data['LimitResurrection']
|
|
ret.mission_table_sub_id = data['MissionTableSubId']
|
|
ret.mission_enemy_lv_limit = data['MissionEnemyLvLimit']
|
|
ret.reward_table_sub_id = data['RewardTableSubId']
|
|
ret.player_trace_table_sub_id = data['PlayerTraceTableSubId']
|
|
ret.success_player_exp = data['SuccessPlayerExp']
|
|
ret.failed_player_exp = data['FailedPlayerExp']
|
|
ret.greed_spawn_wait_count = data['GreedSpawnWaitCount']
|
|
ret.honey_spawn_wait_count = data['HoneySpawnWaitCount']
|
|
ret.menu_display_enemy_set_id = data['MenuDisplayEnemySetId']
|
|
ret.stage_filepath = data['StageFilepath']
|
|
ret.rarity_up_chance_rate = data['RarityUpChanceRate']
|
|
ret.pair_mob_hp_rate = data['PairMobHpRate']
|
|
ret.pair_mob_atk_rate = data['PairMobAtkRate']
|
|
ret.pair_leader_hp_rate = data['PairLeaderHpRate']
|
|
ret.pair_leader_atk_rate = data['PairLeaderAtkRate']
|
|
ret.pair_boss_hp_rate = data['PairBossHpRate']
|
|
ret.pair_boss_atk_rate = data['PairBossAtkRate']
|
|
ret.pair_exp_rate = data['PairExpRate']
|
|
ret.trio_mob_hp_rate = data['TrioMobHpRate']
|
|
ret.trio_mob_atk_rate = data['TrioMobAtkRate']
|
|
ret.trio_leader_hp_rate = data['TrioLeaderHpRate']
|
|
ret.trio_leader_atk_rate = data['TrioLeaderAtkRate']
|
|
ret.trio_boss_hp_rate = data['TrioBossHpRate']
|
|
ret.trio_boss_atk_rate = data['TrioBossAtkRate']
|
|
ret.trio_exp_rate = data['TrioExpRate']
|
|
ret.single_reward_vp = data['SingleRewardVp']
|
|
ret.pair_reward_vp = data['PairRewardVp']
|
|
ret.trio_reward_vp = data['TrioRewardVp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.quest_scene_id) \
|
|
+ encode_short(self.sort_no) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.map_data) \
|
|
+ encode_str(self.unit_data) \
|
|
+ encode_str(self.demo_map) \
|
|
+ encode_str(self.bgm_basic) \
|
|
+ encode_str(self.bgm_boss) \
|
|
+ encode_byte(self.tutorial) \
|
|
+ encode_int(self.chara_comment_id_0) \
|
|
+ encode_int(self.chara_comment_id_1) \
|
|
+ encode_int(self.chara_comment_id_2) \
|
|
+ encode_int(self.chara_comment_id_3) \
|
|
+ encode_int(self.chara_comment_id_4) \
|
|
+ encode_str(self.col_rate) \
|
|
+ encode_int(self.limit_default) \
|
|
+ encode_str(self.limit_time_dec) \
|
|
+ encode_str(self.limit_chara_dec) \
|
|
+ encode_int(self.limit_resurrection) \
|
|
+ encode_int(self.mission_table_sub_id) \
|
|
+ encode_short(self.mission_enemy_lv_limit) \
|
|
+ encode_int(self.reward_table_sub_id) \
|
|
+ encode_int(self.player_trace_table_sub_id) \
|
|
+ encode_int(self.success_player_exp) \
|
|
+ encode_int(self.failed_player_exp) \
|
|
+ encode_int(self.greed_spawn_wait_count) \
|
|
+ encode_int(self.honey_spawn_wait_count) \
|
|
+ encode_int(self.menu_display_enemy_set_id) \
|
|
+ encode_str(self.stage_filepath) \
|
|
+ encode_str(self.rarity_up_chance_rate) \
|
|
+ encode_str(self.pair_mob_hp_rate) \
|
|
+ encode_str(self.pair_mob_atk_rate) \
|
|
+ encode_str(self.pair_leader_hp_rate) \
|
|
+ encode_str(self.pair_leader_atk_rate) \
|
|
+ encode_str(self.pair_boss_hp_rate) \
|
|
+ encode_str(self.pair_boss_atk_rate) \
|
|
+ encode_str(self.pair_exp_rate) \
|
|
+ encode_str(self.trio_mob_hp_rate) \
|
|
+ encode_str(self.trio_mob_atk_rate) \
|
|
+ encode_str(self.trio_leader_hp_rate) \
|
|
+ encode_str(self.trio_leader_atk_rate) \
|
|
+ encode_str(self.trio_boss_hp_rate) \
|
|
+ encode_str(self.trio_boss_atk_rate) \
|
|
+ encode_str(self.trio_exp_rate) \
|
|
+ encode_int(self.single_reward_vp) \
|
|
+ encode_int(self.pair_reward_vp) \
|
|
+ encode_int(self.trio_reward_vp)
|
|
|
|
class QuestExistUnitData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_exist_unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.enemy_kind_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestExistUnitData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_exist_unit_id = data['QuestExistUnitId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.enemy_kind_id = data['EnemyKindId']
|
|
ret.unit_id = data['UnitId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_exist_unit_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.enemy_kind_id) \
|
|
+ encode_int(self.unit_id)
|
|
|
|
class QuestEpisodeAppendRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_episode_append_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_append_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_append_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestEpisodeAppendRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_episode_append_reward_id = data['QuestEpisodeAppendRewardId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.episode_append_id = data['EpisodeAppendId']
|
|
ret.episode_append_num = data['EpisodeAppendNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_episode_append_reward_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.episode_append_id) \
|
|
+ encode_int(self.episode_append_num)
|
|
|
|
class SideQuestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.side_quest_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.episode_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ex_bonus_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.recommend_lv = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.comment_summary, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_introduction, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.start_adv_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_adv_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SideQuestData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.side_quest_id = data['SideQuestId']
|
|
ret.display_name = data['DisplayName']
|
|
ret.episode_num = data['EpisodeNum']
|
|
ret.ex_bonus_table_sub_id = data['ExBonusTableSubId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.recommend_lv = data['RecommendLv']
|
|
ret.comment_summary = data['CommentSummary']
|
|
ret.comment_introduction = data['CommentIntroduction']
|
|
ret.start_adv_name = data['StartAdvName']
|
|
ret.end_adv_name = data['EndAdvName']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.side_quest_id) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.episode_num) \
|
|
+ encode_int(self.ex_bonus_table_sub_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.recommend_lv) \
|
|
+ encode_str(self.comment_summary) \
|
|
+ encode_str(self.comment_introduction) \
|
|
+ encode_str(self.start_adv_name) \
|
|
+ encode_str(self.end_adv_name)
|
|
|
|
class EpisodeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.episode_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_chapter_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.release_episode_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_summary, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_introduction, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.recommend_lv = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ex_bonus_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.start_adv_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_adv_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unlock_still_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.required_release_episode_append_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.required_release_episode_append_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.release_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EpisodeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.episode_id = data['EpisodeId']
|
|
ret.episode_chapter_id = data['EpisodeChapterId']
|
|
ret.release_episode_id = data['ReleaseEpisodeId']
|
|
ret.episode_num = data['EpisodeNum']
|
|
ret.title = data['Title']
|
|
ret.comment_summary = data['CommentSummary']
|
|
ret.comment_introduction = data['CommentIntroduction']
|
|
ret.recommend_lv = data['RecommendLv']
|
|
ret.ex_bonus_table_sub_id = data['ExBonusTableSubId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.start_adv_name = data['StartAdvName']
|
|
ret.end_adv_name = data['EndAdvName']
|
|
ret.unlock_still_id = data['UnlockStillId']
|
|
ret.required_release_episode_append_id = data['RequiredReleaseEpisodeAppendId']
|
|
ret.required_release_episode_append_num = data['RequiredReleaseEpisodeAppendNum']
|
|
ret.release_reward_vp = data['ReleaseRewardVp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.episode_id) \
|
|
+ encode_int(self.episode_chapter_id) \
|
|
+ encode_int(self.release_episode_id) \
|
|
+ encode_int(self.episode_num) \
|
|
+ encode_str(self.title) \
|
|
+ encode_str(self.comment_summary) \
|
|
+ encode_str(self.comment_introduction) \
|
|
+ encode_int(self.recommend_lv) \
|
|
+ encode_int(self.ex_bonus_table_sub_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_str(self.start_adv_name) \
|
|
+ encode_str(self.end_adv_name) \
|
|
+ encode_int(self.unlock_still_id) \
|
|
+ encode_int(self.required_release_episode_append_id) \
|
|
+ encode_short(self.required_release_episode_append_num) \
|
|
+ encode_int(self.release_reward_vp)
|
|
|
|
class EpisodeChapterData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.episode_chapter_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_part_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EpisodeChapterData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.episode_chapter_id = data['EpisodeChapterId']
|
|
ret.episode_part_id = data['EpisodePartId']
|
|
ret.display_name = data['DisplayName']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.episode_chapter_id) \
|
|
+ encode_int(self.episode_part_id) \
|
|
+ encode_str(self.display_name)
|
|
|
|
class EpisodePartData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.episode_part_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EpisodePartData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.episode_part_id = data['EpisodePartId']
|
|
ret.display_name = data['DisplayName']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.episode_part_id) \
|
|
+ encode_str(self.display_name)
|
|
|
|
class TrialTowerData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.trial_tower_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.release_trial_tower_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ex_bonus_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.recommend_lv = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TrialTowerData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.trial_tower_id = data['TrialTowerId']
|
|
ret.release_trial_tower_id = data['ReleaseTrialTowerId']
|
|
ret.ex_bonus_table_sub_id = data['ExBonusTableSubId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.recommend_lv = data['RecommendLv']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.trial_tower_id) \
|
|
+ encode_int(self.release_trial_tower_id) \
|
|
+ encode_int(self.ex_bonus_table_sub_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.recommend_lv)
|
|
|
|
class ExTowerData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ex_tower_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.release_trial_tower_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ExTowerData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ex_tower_id = data['ExTowerId']
|
|
ret.title = data['Title']
|
|
ret.release_trial_tower_id = data['ReleaseTrialTowerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ex_tower_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_int(self.release_trial_tower_id)
|
|
|
|
class ExTowerQuestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ex_tower_quest_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ex_tower_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.release_ex_tower_quest_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.level_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.ex_bonus_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.recommend_lv = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ExTowerQuestData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ex_tower_quest_id = data['ExTowerQuestId']
|
|
ret.ex_tower_id = data['ExTowerId']
|
|
ret.release_ex_tower_quest_id = data['ReleaseExTowerQuestId']
|
|
ret.level_num = data['LevelNum']
|
|
ret.title = data['Title']
|
|
ret.ex_bonus_table_sub_id = data['ExBonusTableSubId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.recommend_lv = data['RecommendLv']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ex_tower_quest_id) \
|
|
+ encode_int(self.ex_tower_id) \
|
|
+ encode_int(self.release_ex_tower_quest_id) \
|
|
+ encode_short(self.level_num) \
|
|
+ encode_str(self.title) \
|
|
+ encode_int(self.ex_bonus_table_sub_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.recommend_lv)
|
|
|
|
class MenuDisplayEnemyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.menu_display_enemy_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.menu_display_enemy_set_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.boss_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.enemy_kind_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "MenuDisplayEnemyData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.menu_display_enemy_id = data['MenuDisplayEnemyId']
|
|
ret.menu_display_enemy_set_id = data['MenuDisplayEnemySetId']
|
|
ret.boss_flag = data['BossFlag']
|
|
ret.enemy_kind_id = data['EnemyKindId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.menu_display_enemy_id) \
|
|
+ encode_int(self.menu_display_enemy_set_id) \
|
|
+ encode_byte(self.boss_flag) \
|
|
+ encode_int(self.enemy_kind_id)
|
|
|
|
class MissionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.mission_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.mission_difficulty_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mission_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.time_limit = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.enemy_set_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.enemy_hide = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "MissionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.mission_id = data['MissionId']
|
|
ret.mission_difficulty_id = data['MissionDifficultyId']
|
|
ret.mission_name = data['MissionName']
|
|
ret.time_limit = data['TimeLimit']
|
|
ret.condition = data['Condition']
|
|
ret.enemy_set_id = data['EnemySetId']
|
|
ret.value1 = data['Value1']
|
|
ret.value2 = data['Value2']
|
|
ret.enemy_hide = data['EnemyHide']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.mission_id) \
|
|
+ encode_int(self.mission_difficulty_id) \
|
|
+ encode_str(self.mission_name) \
|
|
+ encode_int(self.time_limit) \
|
|
+ encode_short(self.condition) \
|
|
+ encode_int(self.enemy_set_id) \
|
|
+ encode_int(self.value1) \
|
|
+ encode_int(self.value2) \
|
|
+ encode_byte(self.enemy_hide)
|
|
|
|
class MissionTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.mission_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mission_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "MissionTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.mission_table_id = data['MissionTableId']
|
|
ret.mission_table_sub_id = data['MissionTableSubId']
|
|
ret.mission_id = data['MissionId']
|
|
ret.rate = data['Rate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.mission_table_id) \
|
|
+ encode_int(self.mission_table_sub_id) \
|
|
+ encode_int(self.mission_id) \
|
|
+ encode_int(self.rate)
|
|
|
|
class MissionDifficultyData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.mission_difficulty_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unanalyzed_log_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "MissionDifficultyData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.mission_difficulty_id = data['MissionDifficultyId']
|
|
ret.skill_exp = data['SkillExp']
|
|
ret.unanalyzed_log_exp = data['UnanalyzedLogExp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.mission_difficulty_id) \
|
|
+ encode_int(self.skill_exp) \
|
|
+ encode_int(self.unanalyzed_log_exp)
|
|
|
|
class BattleCameraData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.battle_camera_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.offset_x, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.offset_y, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.offset_z, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rot_h, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rot_v, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.distance, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.near, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.far, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.fov, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BattleCameraData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.battle_camera_id = data['BattleCameraId']
|
|
ret.offset_x = data['OffsetX']
|
|
ret.offset_y = data['OffsetY']
|
|
ret.offset_z = data['OffsetZ']
|
|
ret.rot_h = data['RotH']
|
|
ret.rot_v = data['RotV']
|
|
ret.distance = data['Distance']
|
|
ret.near = data['Near']
|
|
ret.far = data['Far']
|
|
ret.fov = data['Fov']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.battle_camera_id) \
|
|
+ encode_str(self.offset_x) \
|
|
+ encode_str(self.offset_y) \
|
|
+ encode_str(self.offset_z) \
|
|
+ encode_str(self.rot_h) \
|
|
+ encode_str(self.rot_v) \
|
|
+ encode_str(self.distance) \
|
|
+ encode_str(self.near) \
|
|
+ encode_str(self.far) \
|
|
+ encode_str(self.fov)
|
|
|
|
class ChatMainStoryData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chat_main_story_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.release_condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.release_condition_value = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.first_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ChatMainStoryData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chat_main_story_id = data['ChatMainStoryId']
|
|
ret.release_condition_type = data['ReleaseConditionType']
|
|
ret.release_condition_value = data['ReleaseConditionValue']
|
|
ret.display_name = data['DisplayName']
|
|
ret.first_reward_vp = data['FirstRewardVp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.chat_main_story_id) \
|
|
+ encode_byte(self.release_condition_type) \
|
|
+ encode_int(self.release_condition_value) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.first_reward_vp)
|
|
|
|
class ChatSideStoryData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chat_side_story_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unlock_side_quest_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.release_condition_chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.release_condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.release_condition_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.release_condition_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.first_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ChatSideStoryData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chat_side_story_id = data['ChatSideStoryId']
|
|
ret.unlock_side_quest_id = data['UnlockSideQuestId']
|
|
ret.release_condition_chara_id = data['ReleaseConditionCharaId']
|
|
ret.release_condition_type = data['ReleaseConditionType']
|
|
ret.release_condition_value1 = data['ReleaseConditionValue1']
|
|
ret.release_condition_value2 = data['ReleaseConditionValue2']
|
|
ret.display_name = data['DisplayName']
|
|
ret.first_reward_vp = data['FirstRewardVp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.chat_side_story_id) \
|
|
+ encode_int(self.unlock_side_quest_id) \
|
|
+ encode_short(self.release_condition_chara_id) \
|
|
+ encode_byte(self.release_condition_type) \
|
|
+ encode_int(self.release_condition_value1) \
|
|
+ encode_int(self.release_condition_value2) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.first_reward_vp)
|
|
|
|
class ChatEventStoryData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chat_event_story_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.event_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.release_condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.release_condition_value = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.first_reward_vp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ChatEventStoryData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chat_event_story_id = data['ChatEventStoryId']
|
|
ret.event_id = data['EventId']
|
|
ret.release_condition_type = data['ReleaseConditionType']
|
|
ret.release_condition_value = data['ReleaseConditionValue']
|
|
ret.display_name = data['DisplayName']
|
|
ret.first_reward_vp = data['FirstRewardVp']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.chat_event_story_id) \
|
|
+ encode_int(self.event_id) \
|
|
+ encode_byte(self.release_condition_type) \
|
|
+ encode_int(self.release_condition_value) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.first_reward_vp)
|
|
|
|
class NavigatorCharaData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.navigator_chara_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_start_episode_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_end_episode_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.disp_chara = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "NavigatorCharaData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.navigator_chara_id = data['NavigatorCharaId']
|
|
ret.condition_start_episode_id = data['ConditionStartEpisodeId']
|
|
ret.condition_end_episode_id = data['ConditionEndEpisodeId']
|
|
ret.disp_chara = data['DispChara']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.navigator_chara_id) \
|
|
+ encode_int(self.condition_start_episode_id) \
|
|
+ encode_int(self.condition_end_episode_id) \
|
|
+ encode_int(self.disp_chara)
|
|
|
|
class NavigatorCommentData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.navigator_comment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.menu_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.draw_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_past_menu = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.priority = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_start_episode_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_end_episode_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.only_once = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.only_rico = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.comment_ai, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_rico, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.expression = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.voice_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.show_start_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.show_end_time, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "NavigatorCommentData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.navigator_comment_id = data['NavigatorCommentId']
|
|
ret.menu_id = data['MenuId']
|
|
ret.draw_type = data['DrawType']
|
|
ret.condition_past_menu = data['ConditionPastMenu']
|
|
ret.priority = data['Priority']
|
|
ret.condition_start_episode_id = data['ConditionStartEpisodeId']
|
|
ret.condition_end_episode_id = data['ConditionEndEpisodeId']
|
|
ret.only_once = data['OnlyOnce']
|
|
ret.only_rico = data['OnlyRico']
|
|
ret.comment_ai = data['CommentAi']
|
|
ret.comment_rico = data['CommentRico']
|
|
ret.expression = data['Expression']
|
|
ret.voice_id = data['VoiceId']
|
|
ret.show_start_time = data['ShowStartTime']
|
|
ret.show_end_time = data['ShowEndTime']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.navigator_comment_id) \
|
|
+ encode_int(self.menu_id) \
|
|
+ encode_int(self.draw_type) \
|
|
+ encode_int(self.condition_past_menu) \
|
|
+ encode_int(self.priority) \
|
|
+ encode_int(self.condition_start_episode_id) \
|
|
+ encode_int(self.condition_end_episode_id) \
|
|
+ encode_byte(self.only_once) \
|
|
+ encode_byte(self.only_rico) \
|
|
+ encode_str(self.comment_ai) \
|
|
+ encode_str(self.comment_rico) \
|
|
+ encode_int(self.expression) \
|
|
+ encode_str(self.voice_id) \
|
|
+ encode_str(self.show_start_time) \
|
|
+ encode_str(self.show_end_time)
|
|
|
|
class ExBonusTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ex_bonus_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ex_bonus_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ex_bonus_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ExBonusTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ex_bonus_table_id = data['ExBonusTableId']
|
|
ret.ex_bonus_table_sub_id = data['ExBonusTableSubId']
|
|
ret.ex_bonus_condition_id = data['ExBonusConditionId']
|
|
ret.condition_value1 = data['ConditionValue1']
|
|
ret.condition_value2 = data['ConditionValue2']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ex_bonus_table_id) \
|
|
+ encode_int(self.ex_bonus_table_sub_id) \
|
|
+ encode_int(self.ex_bonus_condition_id) \
|
|
+ encode_int(self.condition_value1) \
|
|
+ encode_int(self.condition_value2) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class ExBonusConditionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ex_bonus_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.hud_format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.format_param_size = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ExBonusConditionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ex_bonus_condition_id = data['ExBonusConditionId']
|
|
ret.format = data['Format']
|
|
ret.hud_format = data['HudFormat']
|
|
ret.format_param_size = data['FomatParamSize']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ex_bonus_condition_id) \
|
|
+ encode_str(self.format) \
|
|
+ encode_str(self.hud_format) \
|
|
+ encode_int(self.format_param_size)
|
|
|
|
class BeginnerMissionProgressesUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.achievement_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.complete_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.complete_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.reward_received_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.reward_received_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionProgressesUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_condition_id = data['BeginnerMissionConditionId']
|
|
ret.achievement_num = data['AchievementNum']
|
|
ret.complete_flag = data['CompleteFlag']
|
|
ret.complete_date = data['CompleteDate']
|
|
ret.reward_received_flag = data['RewardReceivedFlag']
|
|
ret.reward_received_date = data['RewardReceivedDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_condition_id) \
|
|
+ encode_short(self.achievement_num) \
|
|
+ encode_byte(self.complete_flag) \
|
|
+ encode_date_str(self.complete_date) \
|
|
+ encode_byte(self.reward_received_flag) \
|
|
+ encode_date_str(self.reward_received_date)
|
|
|
|
class BeginnerMissionSeatProgressesUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_seat_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.achievement_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.complete_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.complete_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.reward_received_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.reward_received_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionSeatProgressesUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_seat_condition_id = data['BeginnerMissionSeatConditionId']
|
|
ret.achievement_num = data['AchievementNum']
|
|
ret.complete_flag = data['CompleteFlag']
|
|
ret.complete_date = data['CompleteDate']
|
|
ret.reward_received_flag = data['RewardReceivedFlag']
|
|
ret.reward_received_date = data['RewardReceivedDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_seat_condition_id) \
|
|
+ encode_short(self.achievement_num) \
|
|
+ encode_byte(self.complete_flag) \
|
|
+ encode_date_str(self.complete_date) \
|
|
+ encode_byte(self.reward_received_flag) \
|
|
+ encode_date_str(self.reward_received_date)
|
|
|
|
class LinkedSiteRegCampaignUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.reward_received_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.reward_received_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "LinkedSiteRegCampaignUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.reward_received_flag = data['RewardReceivedFlag']
|
|
ret.reward_received_date = data['RewardReceivedDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.reward_received_flag) \
|
|
+ encode_date_str(self.reward_received_date)
|
|
|
|
class HeroLogUnitUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.leader_appointment_normal_card_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.leader_appointment_holographic_card_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_slot_max_release_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "HeroLogUnitUserData":
|
|
ret = cls(b"\x00" * 13, 0)
|
|
ret.hero_log_id = data['HeroLogId']
|
|
ret.leader_appointment_normal_card_num = data['LeaderAppointmentNormalCardNum']
|
|
ret.leader_appointment_holographic_card_num = data['LeaderAppointmentHolographicCardNum']
|
|
ret.skill_slot_max_release_flag = data['SkillSlotMaxReleaseFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.hero_log_id) \
|
|
+ encode_int(self.leader_appointment_normal_card_num) \
|
|
+ encode_int(self.leader_appointment_holographic_card_num) \
|
|
+ encode_byte(self.skill_slot_max_release_flag)
|
|
|
|
class CharaUnitUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.reliability_1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.reliability_2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.motivation_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "CharaUnitUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.chara_id = data['CharaId']
|
|
ret.reliability_1 = data['Reliability1']
|
|
ret.reliability_2 = data['Reliability2']
|
|
ret.motivation_flag = data['MotivationFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.chara_id) \
|
|
+ encode_int(self.reliability_1) \
|
|
+ encode_int(self.reliability_2) \
|
|
+ encode_byte(self.motivation_flag)
|
|
|
|
class AdventureExecUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.status = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.adventure_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.adventure_difficulty_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.last_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.remaining_sec_to_complete = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AdventureExecUserData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.status = data['Status']
|
|
ret.adventure_id = data['AdventureId']
|
|
ret.adventure_difficulty_id = data['AdventureDifficultyId']
|
|
ret.last_start_date = data['LastStartDate']
|
|
ret.remaining_sec_to_complete = data['RemainingSecToComplete']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.status) \
|
|
+ encode_int(self.adventure_id) \
|
|
+ encode_int(self.adventure_difficulty_id) \
|
|
+ encode_date_str(self.last_start_date) \
|
|
+ encode_int(self.remaining_sec_to_complete)
|
|
|
|
class QuestRareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_rare_drop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.drop_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestRareDropData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_rare_drop_id = data['QuestRareDropId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength_min = data['StrengthMin']
|
|
ret.strength_max = data['StrengthMax']
|
|
ret.property_table_sub_id = data['PropertyTableSubId']
|
|
ret.drop_rate = data['DropRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_rare_drop_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num) \
|
|
+ encode_int(self.strength_min) \
|
|
+ encode_int(self.strength_max) \
|
|
+ encode_int(self.property_table_sub_id) \
|
|
+ encode_str(self.drop_rate)
|
|
|
|
class QuestSpecialRareDropSettingData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_special_rare_drop_setting_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.tower_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.start_trial_tower_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.end_trial_tower_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.rare_drop_upward_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.quest_special_rare_drop_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.generic_campaign_period_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSpecialRareDropSettingData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_special_rare_drop_setting_id = data['QuestSpecialRareDropSettingId']
|
|
ret.tower_type = data['TowerType']
|
|
ret.start_trial_tower_id = data['StartTrialTowerId']
|
|
ret.end_trial_tower_id = data['EndTrialTowerId']
|
|
ret.rare_drop_upward_rate = data['RareDropUpwardRate']
|
|
ret.quest_special_rare_drop_sub_id = data['QuestSpecialRareDropSubId']
|
|
ret.generic_campaign_period_id = data['GenericCampaignPeriodId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_special_rare_drop_setting_id) \
|
|
+ encode_byte(self.tower_type) \
|
|
+ encode_short(self.start_trial_tower_id) \
|
|
+ encode_short(self.end_trial_tower_id) \
|
|
+ encode_str(self.rare_drop_upward_rate) \
|
|
+ encode_int(self.quest_special_rare_drop_sub_id) \
|
|
+ encode_int(self.generic_campaign_period_id)
|
|
|
|
class QuestSpecialRareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_special_rare_drop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_special_rare_drop_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.drop_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestSpecialRareDropData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_special_rare_drop_id = data['QuestSpecialRareDropId']
|
|
ret.quest_special_rare_drop_sub_id = data['QuestSpecialRareDropSubId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength_min = data['StrengthMin']
|
|
ret.strength_max = data['StrengthMax']
|
|
ret.property_table_sub_id = data['PropertyTableSubId']
|
|
ret.drop_rate = data['DropRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_special_rare_drop_id) \
|
|
+ encode_int(self.quest_special_rare_drop_sub_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num) \
|
|
+ encode_int(self.strength_min) \
|
|
+ encode_int(self.strength_max) \
|
|
+ encode_int(self.property_table_sub_id) \
|
|
+ encode_str(self.drop_rate)
|
|
|
|
class QuestTutorialData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_tutorial_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.trigger = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.trigger_delay, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.trigger_during, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_range, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.voice_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.comment_pos, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.yui_face, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.arrow_direct, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.arrow_position, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.image_plus, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.image_plus_pos, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.stick_info, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.mark_effect, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.mark_pos, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestTutorialData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_tutorial_id = data['Id']
|
|
ret.trigger = data['Trigger']
|
|
ret.trigger_delay = data['TriggerDelay']
|
|
ret.trigger_during = data['TriggerDuring']
|
|
ret.unit_id = data['UnitId']
|
|
ret.unit_range = data['UnitRange']
|
|
ret.comment_text = data['CommentText']
|
|
ret.voice_id = data['VoiceID']
|
|
ret.comment_pos = data['CommentPos']
|
|
ret.yui_face = data['YuiFace']
|
|
ret.arrow_direct = data['ArrowDirect']
|
|
ret.arrow_position = data['ArrowPosition']
|
|
ret.image_plus = data['ImagePlus']
|
|
ret.image_plus_pos = data['ImagePlusPos']
|
|
ret.stick_info = data['StickInfo']
|
|
ret.mark_effect = data['MarkEffect']
|
|
ret.mark_pos = data['MarkPos']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.quest_tutorial_id) \
|
|
+ encode_int(self.trigger) \
|
|
+ encode_str(self.trigger_delay) \
|
|
+ encode_str(self.trigger_during) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_str(self.unit_range) \
|
|
+ encode_str(self.comment_text) \
|
|
+ encode_str(self.voice_id) \
|
|
+ encode_str(self.comment_pos) \
|
|
+ encode_str(self.yui_face) \
|
|
+ encode_str(self.arrow_direct) \
|
|
+ encode_str(self.arrow_position) \
|
|
+ encode_str(self.image_plus) \
|
|
+ encode_str(self.image_plus_pos) \
|
|
+ encode_str(self.stick_info) \
|
|
+ encode_str(self.mark_effect) \
|
|
+ encode_str(self.mark_pos)
|
|
|
|
class QuestPlayerTraceTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.player_trace_table_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.player_trace_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestPlayerTraceTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.player_trace_table_id = data['PlayerTraceTableId']
|
|
ret.player_trace_table_sub_id = data['PlayerTraceTableSubId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.rate = data['Rate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.player_trace_table_id) \
|
|
+ encode_int(self.player_trace_table_sub_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.rate)
|
|
|
|
class QuestStillData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.still_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.file_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestStillData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.still_id = data['StillId']
|
|
ret.file_name = data['FileName']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.still_id) \
|
|
+ encode_str(self.file_name)
|
|
|
|
class GashaData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.description, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.gasha_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.open_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.free_target_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.reset_hour_list, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.limit_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.open_days = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sort_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_id = data['GashaId']
|
|
ret.name = data['Name']
|
|
ret.description = data['Description']
|
|
ret.gasha_type = data['GashaType']
|
|
ret.open_type = data['OpenType']
|
|
ret.free_target_flag = data['FreeTargetFlag']
|
|
ret.reset_hour_list = data['ResetHourList']
|
|
ret.limit_num = data['LimitNum']
|
|
ret.open_days = data['OpenDays']
|
|
ret.sort_num = data['SortNum']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.description) \
|
|
+ encode_byte(self.gasha_type) \
|
|
+ encode_byte(self.open_type) \
|
|
+ encode_byte(self.free_target_flag) \
|
|
+ encode_str(self.reset_hour_list) \
|
|
+ encode_short(self.limit_num) \
|
|
+ encode_short(self.open_days) \
|
|
+ encode_int(self.sort_num) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class GashaHeaderData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_header_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.step_no = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.step_progress_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.platform = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.use_type_1 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.use_type_2 = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.provision_num = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.premium_lottery_num = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.premium_lottery_executable_num = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.use_type_1_first_use_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_type_1_base_use_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_type_1_extra_use_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_type_2_first_use_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_type_2_base_use_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_type_2_extra_use_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.yui_chance_log_open_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.yui_chance_rarity_up_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaHeaderData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_header_id = data['GashaHeaderId']
|
|
ret.gasha_id = data['GashaId']
|
|
ret.step_no = data['StepNo']
|
|
ret.step_progress_flag = data['StepProgressFlag']
|
|
ret.platform = data['Platform']
|
|
ret.use_type_1 = data['UseType1']
|
|
ret.use_type_2 = data['UseType2']
|
|
ret.provision_num = data['ProvisionNum']
|
|
ret.premium_lottery_num = data['PremiumLotteryNum']
|
|
ret.premium_lottery_executable_num = data['PremiumLotteryExecutableNum']
|
|
ret.use_type_1_first_use_num = data['UseType1FirstUseNum']
|
|
ret.use_type_1_base_use_num = data['UseType1BaseUseNum']
|
|
ret.use_type_1_extra_use_num = data['UseType1ExtraUseNum']
|
|
ret.use_type_2_first_use_num = data['UseType2FirstUseNum']
|
|
ret.use_type_2_base_use_num = data['UseType2BaseUseNum']
|
|
ret.use_type_2_extra_use_num = data['UseType2ExtraUseNum']
|
|
ret.yui_chance_log_open_rate = data['YuiChanceLogOpenRate']
|
|
ret.yui_chance_rarity_up_rate = data['YuiChanceRarityUpRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_header_id) \
|
|
+ encode_int(self.gasha_id) \
|
|
+ encode_byte(self.step_no) \
|
|
+ encode_byte(self.step_progress_flag) \
|
|
+ encode_byte(self.platform) \
|
|
+ encode_byte(self.use_type_1) \
|
|
+ encode_byte(self.use_type_2) \
|
|
+ encode_byte(self.provision_num) \
|
|
+ encode_byte(self.premium_lottery_num) \
|
|
+ encode_byte(self.premium_lottery_executable_num) \
|
|
+ encode_int(self.use_type_1_first_use_num) \
|
|
+ encode_int(self.use_type_1_base_use_num) \
|
|
+ encode_int(self.use_type_1_extra_use_num) \
|
|
+ encode_int(self.use_type_2_first_use_num) \
|
|
+ encode_int(self.use_type_2_base_use_num) \
|
|
+ encode_int(self.use_type_2_extra_use_num) \
|
|
+ encode_str(self.yui_chance_log_open_rate) \
|
|
+ encode_str(self.yui_chance_rarity_up_rate)
|
|
|
|
class GashaLotteryRarityData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_lottery_rarity_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_header_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.lottery_rarity_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.lottery_rarity_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.premium_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaLotteryRarityData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_lottery_rarity_id = data['GashaLotteryRarityId']
|
|
ret.gasha_id = data['GashaId']
|
|
ret.gasha_header_id = data['GashaHeaderId']
|
|
ret.lottery_rarity_type = data['LotteryRarityType']
|
|
ret.lottery_rarity_rate = data['LotteryRarityRate']
|
|
ret.premium_rate = data['PremiumRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_lottery_rarity_id) \
|
|
+ encode_int(self.gasha_id) \
|
|
+ encode_int(self.gasha_header_id) \
|
|
+ encode_byte(self.lottery_rarity_type) \
|
|
+ encode_str(self.lottery_rarity_rate) \
|
|
+ encode_str(self.premium_rate)
|
|
|
|
class GashaPrizeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_prize_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.lottery_rarity_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unanalyzed_log_grade_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.correction_rate = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.pickup_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.property_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaPrizeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_prize_id = data['GashaPrizeId']
|
|
ret.gasha_id = data['GashaId']
|
|
ret.lottery_rarity_type = data['LotteryRarityType']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.unanalyzed_log_grade_id = data['UnanalyzedLogGradeId']
|
|
ret.correction_rate = data['CorrectionRate']
|
|
ret.pickup_flag = data['PickupFlag']
|
|
ret.property_table_sub_id = data['PropertyTableSubId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_prize_id) \
|
|
+ encode_int(self.gasha_id) \
|
|
+ encode_byte(self.lottery_rarity_type) \
|
|
+ encode_int(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num) \
|
|
+ encode_int(self.unanalyzed_log_grade_id) \
|
|
+ encode_short(self.correction_rate) \
|
|
+ encode_byte(self.pickup_flag) \
|
|
+ encode_int(self.property_table_sub_id)
|
|
|
|
class ComebackEventData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.comeback_event_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.comeback_event_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.reward_set_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.require_days = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ComebackEventData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.comeback_event_id = data['ComebackEventId']
|
|
ret.comeback_event_sub_id = data['ComebackEventSubId']
|
|
ret.display_name = data['DisplayName']
|
|
ret.reward_set_sub_id = data['RewardSetSubId']
|
|
ret.require_days = data['RequireDays']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.comeback_event_id) \
|
|
+ encode_int(self.comeback_event_sub_id) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.reward_set_sub_id) \
|
|
+ encode_short(self.require_days)
|
|
|
|
class AdBannerData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.category = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.sort_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.active_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AdBannerData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
ret.category = data['Category']
|
|
ret.sort_num = data['SortNum']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
ret.active_flag = data['ActiveFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ad_banner_id) \
|
|
+ encode_byte(self.category) \
|
|
+ encode_int(self.sort_num) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date) \
|
|
+ encode_byte(self.active_flag)
|
|
|
|
class EventsData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.event_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.event_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.chat_open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.chat_open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.news_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.help_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EventsData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.event_id = data['EventId']
|
|
ret.event_type = data['EventType']
|
|
ret.title = data['Title']
|
|
ret.param_1 = data['Param1']
|
|
ret.param_2 = data['Param2']
|
|
ret.param_3 = data['Param3']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
ret.posting_start_date = data['PostingStartDate']
|
|
ret.posting_end_date = data['PostingEndDate']
|
|
ret.chat_open_start_date = data['ChatOpenStartDate']
|
|
ret.chat_open_end_date = data['ChatOpenEndDate']
|
|
ret.news_id = data['NewId']
|
|
ret.help_id = data['HelpId']
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.event_id) \
|
|
+ encode_byte(self.event_type) \
|
|
+ encode_str(self.title) \
|
|
+ encode_str(self.param_1) \
|
|
+ encode_str(self.param_2) \
|
|
+ encode_str(self.param_3) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date) \
|
|
+ encode_date_str(self.posting_start_date) \
|
|
+ encode_date_str(self.posting_end_date) \
|
|
+ encode_date_str(self.chat_open_start_date) \
|
|
+ encode_date_str(self.chat_open_end_date) \
|
|
+ encode_int(self.news_id) \
|
|
+ encode_int(self.help_id) \
|
|
+ encode_int(self.ad_banner_id)
|
|
|
|
class TreasureHuntsData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntsData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_id = data['TreasureHuntId']
|
|
ret.title = data['Title']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_id) \
|
|
+ encode_str(self.title)
|
|
|
|
class TreasureHuntWholeTasksData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_whole_task_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.treasure_hunt_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.task_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.achievement_possible_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.get_event_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_value_accumulation_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_value_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_4, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_5, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntWholeTasksData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_whole_task_id = data['TreasureHuntWholeTaskId']
|
|
ret.treasure_hunt_id = data['TreasureHuntId']
|
|
ret.task_type = data['TaskType']
|
|
ret.achievement_possible_num = data['AchievementPossibleNum']
|
|
ret.get_event_point = data['GetEventPoint']
|
|
ret.condition_type = data['ConditionType']
|
|
ret.condition_value_accumulation_flag = data['ConditionValueAccumulationFlag']
|
|
ret.condition_value_1 = data['ConditionValue1']
|
|
ret.condition_value_2 = data['ConditionValue2']
|
|
ret.condition_value_3 = data['ConditionValue3']
|
|
ret.condition_value_4 = data['ConditionValue4']
|
|
ret.condition_value_5 = data['ConditionValue5']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_whole_task_id) \
|
|
+ encode_int(self.treasure_hunt_id) \
|
|
+ encode_byte(self.task_type) \
|
|
+ encode_short(self.achievement_possible_num) \
|
|
+ encode_int(self.get_event_point) \
|
|
+ encode_byte(self.condition_type) \
|
|
+ encode_byte(self.condition_value_accumulation_flag) \
|
|
+ encode_str(self.condition_value_1) \
|
|
+ encode_str(self.condition_value_2) \
|
|
+ encode_str(self.condition_value_3) \
|
|
+ encode_str(self.condition_value_4) \
|
|
+ encode_str(self.condition_value_5) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date)
|
|
|
|
class TreasureHuntIndividualTasksData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_individual_task_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.treasure_hunt_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.task_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.quest_scene_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.achievement_possible_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.get_event_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_value_accumulation_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_value_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_4, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value_5, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntIndividualTasksData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_individual_task_id = data['TreasureHuntIndividualTaskId']
|
|
ret.treasure_hunt_id = data['TreasureHuntId']
|
|
ret.task_type = data['TaskType']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.achievement_possible_num = data['AchievementPossibleNum']
|
|
ret.get_event_point = data['GetEventPoint']
|
|
ret.condition_type = data['ConditionType']
|
|
ret.condition_value_accumulation_flag = data['ConditionValueAccumulationFlag']
|
|
ret.condition_value_1 = data['ConditionValue1']
|
|
ret.condition_value_2 = data['ConditionValue2']
|
|
ret.condition_value_3 = data['ConditionValue3']
|
|
ret.condition_value_4 = data['ConditionValue4']
|
|
ret.condition_value_5 = data['ConditionValue5']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_individual_task_id) \
|
|
+ encode_int(self.treasure_hunt_id) \
|
|
+ encode_byte(self.task_type) \
|
|
+ encode_short(self.quest_scene_id) \
|
|
+ encode_short(self.achievement_possible_num) \
|
|
+ encode_int(self.get_event_point) \
|
|
+ encode_byte(self.condition_type) \
|
|
+ encode_byte(self.condition_value_accumulation_flag) \
|
|
+ encode_str(self.condition_value_1) \
|
|
+ encode_str(self.condition_value_2) \
|
|
+ encode_str(self.condition_value_3) \
|
|
+ encode_str(self.condition_value_4) \
|
|
+ encode_str(self.condition_value_5) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date)
|
|
|
|
class TreasureHuntSpecialEffectsData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_special_effect_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.treasure_hunt_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.special_effect_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.special_effect_coefficient, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.target_common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.target_common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.obtaining_location_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.obtaining_location_param, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntSpecialEffectsData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_special_effect_id = data['TreasureHuntSpecialEffectId']
|
|
ret.treasure_hunt_id = data['TreasureHuntId']
|
|
ret.special_effect_type = data['SpecialEffectType']
|
|
ret.special_effect_coefficient = data['SpecialEffectCoefficient']
|
|
ret.target_common_reward_type = data['TargetCommonRewardType']
|
|
ret.target_common_reward_id = data['TargetCommonRewardId']
|
|
ret.obtaining_location_type = data['ObtainingLocationType']
|
|
ret.obtaining_location_param = data['ObtainingLocationParam']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_special_effect_id) \
|
|
+ encode_int(self.treasure_hunt_id) \
|
|
+ encode_byte(self.special_effect_type) \
|
|
+ encode_str(self.special_effect_coefficient) \
|
|
+ encode_byte(self.target_common_reward_type) \
|
|
+ encode_int(self.target_common_reward_id) \
|
|
+ encode_byte(self.obtaining_location_type) \
|
|
+ encode_str(self.obtaining_location_param) \
|
|
+ encode_date_str(self.open_start_date)
|
|
|
|
class TreasureHuntEventPointRewardCommonRewardsData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_event_point_reward_common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.treasure_hunt_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.need_event_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntEventPointRewardCommonRewardsData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_event_point_reward_common_reward_id = data['TreasureHuntEventPointRewardCommonRewardId']
|
|
ret.treasure_hunt_id = data['TreasureHuntId']
|
|
ret.need_event_point = data['NeedEventPoint']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_event_point_reward_common_reward_id) \
|
|
+ encode_int(self.treasure_hunt_id) \
|
|
+ encode_int(self.need_event_point) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class TreasureHuntEventPointRewardTitlesData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_event_point_reward_title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.treasure_hunt_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.need_event_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntEventPointRewardTitlesData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_event_point_reward_title_id = data['TreasureHuntEventPointRewardTitleId']
|
|
ret.treasure_hunt_id = data['TreasureHuntId']
|
|
ret.need_event_point = data['NeedEventPoint']
|
|
ret.title_id = data['TitleId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_event_point_reward_title_id) \
|
|
+ encode_int(self.treasure_hunt_id) \
|
|
+ encode_int(self.need_event_point) \
|
|
+ encode_int(self.title_id)
|
|
|
|
class TreasureHuntTaskTextData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.treasure_hunt_task_text_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.task_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "TreasureHuntTaskTextData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.treasure_hunt_task_text_id = data['TreasureHuntTaskTextId']
|
|
ret.task_type = data['TaskType']
|
|
ret.condition_type = data['ConditionType']
|
|
ret.format = data['Format']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.treasure_hunt_task_text_id) \
|
|
+ encode_byte(self.task_type) \
|
|
+ encode_byte(self.condition_type) \
|
|
+ encode_str(self.format)
|
|
|
|
class BnidSerialCodeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.bnid_item_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.serial_code_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.category = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.description, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BnidSerialCodeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.bnid_item_id = data['BnidItemId']
|
|
ret.serial_code_type = data['SerialCodeType']
|
|
ret.category = data['Category']
|
|
ret.description = data['Description']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.bnid_item_id) \
|
|
+ encode_byte(self.serial_code_type) \
|
|
+ encode_byte(self.category) \
|
|
+ encode_str(self.description) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date)
|
|
|
|
class BnidSerialCodeRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.bnid_item_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BnidSerialCodeRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.bnid_item_id = data['BnidItemId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.bnid_item_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class SupportLogData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.rarity = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.support_log_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sale_price = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.composition_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_exp = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_rank = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.group_no = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.adaptable_appear_append = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.punisher_appear_append = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.passive_state, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.power_default_value = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.clt_default_value = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_1_power = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_1_clt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_2_power = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_2_clt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_3_power = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_3_clt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_4_power = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_4_clt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_5_power = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_5_clt = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.normal_leader = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.holo_leader = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ui_display_power_title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.ui_display_power_content, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.prefab, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cutin_mode, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.skill_voice_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.skill_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.name_in_skill_cutin, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.skill_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.skill_text_in_skill_cutin, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.chara_info, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cutin_image, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cutin_image_awake, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.status_chara_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.status_chara_icon_awake, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_display_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.collection_empty_frame_display_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SupportLogData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.support_log_id = data['SupportLogId']
|
|
ret.chara_id = data['CharaId']
|
|
ret.name = data['Name']
|
|
ret.rarity = data['Rarity']
|
|
ret.support_log_type_id = data['SupportLogTypeId']
|
|
ret.sale_price = data['SalePrice']
|
|
ret.composition_exp = data['CompositionExp']
|
|
ret.awakening_exp = data['AwakeningExp']
|
|
ret.use_rank = data['UseRank']
|
|
ret.group_no = data['GroupNo']
|
|
ret.adaptable_appear_append = data['AdaptableAppearAppend']
|
|
ret.punisher_appear_append = data['PunisherAppearAppend']
|
|
ret.state = data['State']
|
|
ret.passive_state = data['PassiveState']
|
|
ret.power_default_value = data['PowerDefaultValue']
|
|
ret.clt_default_value = data['CltDefaultValue']
|
|
ret.awakening_1_power = data['Awakening1Power']
|
|
ret.awakening_1_clt = data['Awakening1Clt']
|
|
ret.awakening_2_power = data['Awakening2Power']
|
|
ret.awakening_2_clt = data['Awakening2Clt']
|
|
ret.awakening_3_power = data['Awakening3Power']
|
|
ret.awakening_3_clt = data['Awakening3Clt']
|
|
ret.awakening_4_power = data['Awakening4Power']
|
|
ret.awakening_4_clt = data['Awakening4Clt']
|
|
ret.awakening_5_power = data['Awakening5Power']
|
|
ret.awakening_5_clt = data['Awakening5Clt']
|
|
ret.normal_leader = data['NormalLeader']
|
|
ret.holo_leader = data['HoloLeader']
|
|
ret.ui_display_power_title = data['UiDisplayPowerTitle']
|
|
ret.ui_display_power_content = data['UiDisplayPowerContent']
|
|
ret.prefab = data['Prefab']
|
|
ret.cutin_mode = data['CutinMode']
|
|
ret.skill_voice_id = data['SkillVoiceId']
|
|
ret.skill_name = data['SkillName']
|
|
ret.name_in_skill_cutin = data['NameInSkillCutin']
|
|
ret.skill_text = data['SkillText']
|
|
ret.skill_text_in_skill_cutin = data['SkillTextInSkillCutin']
|
|
ret.chara_info = data['CharaInfo']
|
|
ret.cutin_image = data['CutinImage']
|
|
ret.cutin_image_awake = data['CutinImageAwake']
|
|
ret.status_chara_icon = data['StatusCharaIcon']
|
|
ret.status_chara_icon_awake = data['StatusCharaIconAwake']
|
|
ret.collection_display_start_date = data['CollectionDisplayStartDate']
|
|
ret.collection_empty_frame_display_flag = data['CollectionEmptyFrameDisplayFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.support_log_id) \
|
|
+ encode_short(self.chara_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_byte(self.rarity) \
|
|
+ encode_short(self.support_log_type_id) \
|
|
+ encode_int(self.sale_price) \
|
|
+ encode_int(self.composition_exp) \
|
|
+ encode_int(self.awakening_exp) \
|
|
+ encode_short(self.use_rank) \
|
|
+ encode_short(self.group_no) \
|
|
+ encode_short(self.adaptable_appear_append) \
|
|
+ encode_short(self.punisher_appear_append) \
|
|
+ encode_str(self.state) \
|
|
+ encode_str(self.passive_state) \
|
|
+ encode_int(self.power_default_value) \
|
|
+ encode_int(self.clt_default_value) \
|
|
+ encode_int(self.awakening_1_power) \
|
|
+ encode_int(self.awakening_1_clt) \
|
|
+ encode_int(self.awakening_2_power) \
|
|
+ encode_int(self.awakening_2_clt) \
|
|
+ encode_int(self.awakening_3_power) \
|
|
+ encode_int(self.awakening_3_clt) \
|
|
+ encode_int(self.awakening_4_power) \
|
|
+ encode_int(self.awakening_4_clt) \
|
|
+ encode_int(self.awakening_5_power) \
|
|
+ encode_int(self.awakening_5_clt) \
|
|
+ encode_int(self.normal_leader) \
|
|
+ encode_int(self.holo_leader) \
|
|
+ encode_str(self.ui_display_power_title) \
|
|
+ encode_str(self.ui_display_power_content) \
|
|
+ encode_str(self.prefab) \
|
|
+ encode_str(self.cutin_mode) \
|
|
+ encode_str(self.skill_voice_id) \
|
|
+ encode_str(self.skill_name) \
|
|
+ encode_str(self.name_in_skill_cutin) \
|
|
+ encode_str(self.skill_text) \
|
|
+ encode_str(self.skill_text_in_skill_cutin) \
|
|
+ encode_str(self.chara_info) \
|
|
+ encode_str(self.cutin_image) \
|
|
+ encode_str(self.cutin_image_awake) \
|
|
+ encode_str(self.status_chara_icon) \
|
|
+ encode_str(self.status_chara_icon_awake) \
|
|
+ encode_date_str(self.collection_display_start_date) \
|
|
+ encode_byte(self.collection_empty_frame_display_flag)
|
|
|
|
class SupportLogTypeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.support_log_type_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "SupportLogTypeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.support_log_type_id = data['SupportLogTypeId']
|
|
ret.name = data['Name']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_short(self.support_log_type_id) \
|
|
+ encode_str(self.name)
|
|
|
|
class EpisodeAppendData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.episode_append_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_append_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.sale_possible_flag = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sale_price = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.episode_append_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EpisodeAppendData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.episode_append_id = data['EpisodeAppendId']
|
|
ret.episode_append_type = data['EpisodeAppendType']
|
|
ret.name = data['Name']
|
|
ret.flavor_text = data['FlavorText']
|
|
ret.sale_possible_flag = data['SalePossibleFlag']
|
|
ret.sale_price = data['SalePrice']
|
|
ret.episode_append_icon = data['EpisodeAppendIcon']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.episode_append_id) \
|
|
+ encode_byte(self.episode_append_type) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.flavor_text) \
|
|
+ encode_int(self.sale_possible_flag) \
|
|
+ encode_int(self.sale_price) \
|
|
+ encode_str(self.episode_append_icon)
|
|
|
|
class QuestDefragMatchQuestData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_quest_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.quest_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_quest_boss_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.display_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.map_no = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_data1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unit_data2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unit_data3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.adaptable_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.punisher_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.comment_details, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestDefragMatchQuestData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_quest_id = data['DefragMatchQuestId']
|
|
ret.quest_scene_id = data['QuestSceneId']
|
|
ret.defrag_match_quest_boss_table_sub_id = data['DefragMatchBossTableSubId']
|
|
ret.display_name = data['DisplayName']
|
|
ret.map_no = data['VsModeNo']
|
|
ret.unit_data1 = data['UnitData1']
|
|
ret.unit_data2 = data['UnitData2']
|
|
ret.unit_data3 = data['UnitData3']
|
|
ret.adaptable_rate = data['AdaptableRate']
|
|
ret.punisher_flag = data['PunisherFlag']
|
|
ret.comment_details = data['CommentDetails']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_quest_id) \
|
|
+ encode_int(self.quest_scene_id) \
|
|
+ encode_int(self.defrag_match_quest_boss_table_sub_id) \
|
|
+ encode_str(self.display_name) \
|
|
+ encode_int(self.map_no) \
|
|
+ encode_str(self.unit_data1) \
|
|
+ encode_str(self.unit_data2) \
|
|
+ encode_str(self.unit_data3) \
|
|
+ encode_str(self.adaptable_rate) \
|
|
+ encode_byte(self.punisher_flag) \
|
|
+ encode_str(self.comment_details)
|
|
|
|
class QuestDefragMatchQuestBossTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_quest_boss_table_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_quest_boss_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.wave = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.rate = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestDefragMatchQuestBossTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_quest_boss_table_id = data['DefragMatchBossTableId']
|
|
ret.defrag_match_quest_boss_table_sub_id = data['DefragMatchBossTableSubId']
|
|
ret.wave = data['Wave']
|
|
ret.type = data['Type']
|
|
ret.unit_id = data['UnitId']
|
|
ret.rate = data['Rate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_quest_boss_table_id) \
|
|
+ encode_int(self.defrag_match_quest_boss_table_sub_id) \
|
|
+ encode_int(self.wave) \
|
|
+ encode_int(self.type) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.rate)
|
|
|
|
class DefragMatchData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.season_no = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.first_attack_bonus_coefficient, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.last_attack_bonus_coefficient, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.memo, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.season_no = data['SeasonNo']
|
|
ret.title = data['Title']
|
|
ret.first_attack_bonus_coefficient = data['FirstAttackBonusCoefficient']
|
|
ret.last_attack_bonus_coefficient = data['LastAttackBonusCoefficient']
|
|
ret.memo = data['Memo']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_short(self.season_no) \
|
|
+ encode_str(self.title) \
|
|
+ encode_str(self.first_attack_bonus_coefficient) \
|
|
+ encode_str(self.last_attack_bonus_coefficient) \
|
|
+ encode_str(self.memo)
|
|
|
|
class DefragMatchSeedData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_seed_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.check_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.need_class_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.need_cleared_trial_tower_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.get_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_league_score = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.set_class_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchSeedData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_seed_id = data['DefragMatchSeedId']
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.check_type = data['CheckType']
|
|
ret.need_class_num = data['NeedClassNum']
|
|
ret.need_cleared_trial_tower_id = data['NeedClearedTrialTowerId']
|
|
ret.get_league_point = data['GetLeaguePoint']
|
|
ret.get_league_score = data['GetLeagueScore']
|
|
ret.set_class_num = data['SetClassNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_seed_id) \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_byte(self.check_type) \
|
|
+ encode_short(self.need_class_num) \
|
|
+ encode_short(self.need_cleared_trial_tower_id) \
|
|
+ encode_int(self.get_league_point) \
|
|
+ encode_short(self.get_league_score) \
|
|
+ encode_short(self.set_class_num)
|
|
|
|
class DefragMatchSpecialEffectData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_special_effec_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.special_effect_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.special_effect_coefficient, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.target_chara_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchSpecialEffectData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_special_effec_id = data['DefragMatchSpecialEffectsId']
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.special_effect_type = data['SpecialEffectType']
|
|
ret.special_effect_coefficient = data['SpecialEffectCoefficient']
|
|
ret.target_chara_id = data['TargetCharaId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_special_effec_id) \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_byte(self.special_effect_type) \
|
|
+ encode_str(self.special_effect_coefficient) \
|
|
+ encode_short(self.target_chara_id)
|
|
|
|
class DefragMatchGradeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_grade_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.class_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.grade_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.class_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.promotion_line_league_score = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.demotion_line_league_score = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.league_score_decrease_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.target_league_point_1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.target_league_point_2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mvp_add_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.mob_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.normal_boss_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.adaptable_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.punisher_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.punisher_appearance_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.cpu_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.record_medal_drop_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.target_league_point_coefficient, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.reward_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchGradeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_grade_id = data['DefragMatchGradeId']
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.class_num = data['ClassNum']
|
|
ret.grade_name = data['GradeName']
|
|
ret.class_name = data['ClassName']
|
|
ret.promotion_line_league_score = data['PromotionLineLeagueScore']
|
|
ret.demotion_line_league_score = data['DemotionLineLeagueScore']
|
|
ret.league_score_decrease_flag = data['LeagueScoreDecreaseFlag']
|
|
ret.target_league_point_1 = data['TargetLeaguePoint1']
|
|
ret.target_league_point_2 = data['TargetLeaguePoint2']
|
|
ret.mvp_add_league_point = data['MvpAddLeaguePoint']
|
|
ret.mob_level = data['MobLevel']
|
|
ret.normal_boss_level = data['NormalBossLevel']
|
|
ret.adaptable_level = data['AdaptableLevel']
|
|
ret.punisher_level = data['PunisherLevel']
|
|
ret.punisher_appearance_rate = data['PunisherAppearanceRate']
|
|
ret.cpu_level = data['CpuLevel']
|
|
ret.record_medal_drop_num = data['RecordMedalDropNum']
|
|
ret.target_league_point_coefficient = data['TargetLeaguePointCoefficient']
|
|
ret.reward_table_sub_id = data['RewardTableSubId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_grade_id) \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_short(self.class_num) \
|
|
+ encode_str(self.grade_name) \
|
|
+ encode_str(self.class_name) \
|
|
+ encode_short(self.promotion_line_league_score) \
|
|
+ encode_short(self.demotion_line_league_score) \
|
|
+ encode_byte(self.league_score_decrease_flag) \
|
|
+ encode_int(self.target_league_point_1) \
|
|
+ encode_int(self.target_league_point_2) \
|
|
+ encode_int(self.mvp_add_league_point) \
|
|
+ encode_short(self.mob_level) \
|
|
+ encode_short(self.normal_boss_level) \
|
|
+ encode_short(self.adaptable_level) \
|
|
+ encode_short(self.punisher_level) \
|
|
+ encode_str(self.punisher_appearance_rate) \
|
|
+ encode_short(self.cpu_level) \
|
|
+ encode_short(self.record_medal_drop_num) \
|
|
+ encode_str(self.target_league_point_coefficient) \
|
|
+ encode_int(self.reward_table_sub_id)
|
|
|
|
class DefragMatchCpuUnitData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_cpu_unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_start_defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_end_defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_start_class_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_end_class_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_hero_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_log_level = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.hero_log_property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.hero_log_property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_equipment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_enhancement_value = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.main_weapon_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.main_weapon_property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.main_weapon_property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_equipment_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_enhancement_value = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equipment_awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.sub_equipment_property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.sub_equipment_property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.skill_slot1_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_slot2_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_slot3_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_slot4_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.skill_slot5_skill_id = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchCpuUnitData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_cpu_unit_id = data['DefragMatchCpuUnitsId']
|
|
ret.appearance_start_defrag_match_id = data['AppearanceStartDefragMatchId']
|
|
ret.appearance_end_defrag_match_id = data['AppearanceEndDefragMatchId']
|
|
ret.appearance_start_class_num = data['AppearanceStartClassNum']
|
|
ret.appearance_end_class_num = data['AppearanceEndClassNum']
|
|
ret.hero_log_hero_log_id = data['HeroLogHeroLogId']
|
|
ret.hero_log_log_level = data['HeroLogLogLevel']
|
|
ret.hero_log_awakening_stage = data['HeroLogAwakeningStage']
|
|
ret.hero_log_property1_property_id = data['HeroLogProperty1PropertyId']
|
|
ret.hero_log_property1_value1 = data['HeroLogProperty1Value1']
|
|
ret.hero_log_property1_value2 = data['HeroLogProperty1Value2']
|
|
ret.hero_log_property2_property_id = data['HeroLogProperty2PropertyId']
|
|
ret.hero_log_property2_value1 = data['HeroLogProperty2Value1']
|
|
ret.hero_log_property2_value2 = data['HeroLogProperty2Value2']
|
|
ret.hero_log_property3_property_id = data['HeroLogProperty3PropertyId']
|
|
ret.hero_log_property3_value1 = data['HeroLogProperty3Value1']
|
|
ret.hero_log_property3_value2 = data['HeroLogProperty3Value2']
|
|
ret.hero_log_property4_property_id = data['HeroLogProperty4PropertyId']
|
|
ret.hero_log_property4_value1 = data['HeroLogProperty4Value1']
|
|
ret.hero_log_property4_value2 = data['HeroLogProperty4Value2']
|
|
ret.main_weapon_equipment_id = data['MainWeaponEquipmentId']
|
|
ret.main_weapon_enhancement_value = data['MainWeaponEnhancementValue']
|
|
ret.main_weapon_awakening_stage = data['MainWeaponAwakeningStage']
|
|
ret.main_weapon_property1_property_id = data['MainWeaponProperty1PropertyId']
|
|
ret.main_weapon_property1_value1 = data['MainWeaponProperty1Value1']
|
|
ret.main_weapon_property1_value2 = data['MainWeaponProperty1Value2']
|
|
ret.main_weapon_property2_property_id = data['MainWeaponProperty2PropertyId']
|
|
ret.main_weapon_property2_value1 = data['MainWeaponProperty2Value1']
|
|
ret.main_weapon_property2_value2 = data['MainWeaponProperty2Value2']
|
|
ret.main_weapon_property3_property_id = data['MainWeaponProperty3PropertyId']
|
|
ret.main_weapon_property3_value1 = data['MainWeaponProperty3Value1']
|
|
ret.main_weapon_property3_value2 = data['MainWeaponProperty3Value2']
|
|
ret.main_weapon_property4_property_id = data['MainWeaponProperty4PropertyId']
|
|
ret.main_weapon_property4_value1 = data['MainWeaponProperty4Value1']
|
|
ret.main_weapon_property4_value2 = data['MainWeaponProperty4Value2']
|
|
ret.sub_equipment_equipment_id = data['SubEquipmentEquipmentId']
|
|
ret.sub_equipment_enhancement_value = data['SubEquipmentEnhancementValue']
|
|
ret.sub_equipment_awakening_stage = data['SubEquipmentAwakeningStage']
|
|
ret.sub_equipment_property1_property_id = data['SubEquipmentProperty1PropertyId']
|
|
ret.sub_equipment_property1_value1 = data['SubEquipmentProperty1Value1']
|
|
ret.sub_equipment_property1_value2 = data['SubEquipmentProperty1Value2']
|
|
ret.sub_equipment_property2_property_id = data['SubEquipmentProperty2PropertyId']
|
|
ret.sub_equipment_property2_value1 = data['SubEquipmentProperty2Value1']
|
|
ret.sub_equipment_property2_value2 = data['SubEquipmentProperty2Value2']
|
|
ret.sub_equipment_property3_property_id = data['SubEquipmentProperty3PropertyId']
|
|
ret.sub_equipment_property3_value1 = data['SubEquipmentProperty3Value1']
|
|
ret.sub_equipment_property3_value2 = data['SubEquipmentProperty3Value2']
|
|
ret.sub_equipment_property4_property_id = data['SubEquipmentProperty4PropertyId']
|
|
ret.sub_equipment_property4_value1 = data['SubEquipmentProperty4Value1']
|
|
ret.sub_equipment_property4_value2 = data['SubEquipmentProperty4Value2']
|
|
ret.skill_slot1_skill_id = data['SkillSlot1SkillId']
|
|
ret.skill_slot2_skill_id = data['SkillSlot2SkillId']
|
|
ret.skill_slot3_skill_id = data['SkillSlot3SkillId']
|
|
ret.skill_slot4_skill_id = data['SkillSlot4SkillId']
|
|
ret.skill_slot5_skill_id = data['SkillSlot5SkillId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_cpu_unit_id) \
|
|
+ encode_int(self.appearance_start_defrag_match_id) \
|
|
+ encode_int(self.appearance_end_defrag_match_id) \
|
|
+ encode_int(self.appearance_start_class_num) \
|
|
+ encode_int(self.appearance_end_class_num) \
|
|
+ encode_int(self.hero_log_hero_log_id) \
|
|
+ encode_short(self.hero_log_log_level) \
|
|
+ encode_short(self.hero_log_awakening_stage) \
|
|
+ encode_int(self.hero_log_property1_property_id) \
|
|
+ encode_int(self.hero_log_property1_value1) \
|
|
+ encode_int(self.hero_log_property1_value2) \
|
|
+ encode_int(self.hero_log_property2_property_id) \
|
|
+ encode_int(self.hero_log_property2_value1) \
|
|
+ encode_int(self.hero_log_property2_value2) \
|
|
+ encode_int(self.hero_log_property3_property_id) \
|
|
+ encode_int(self.hero_log_property3_value1) \
|
|
+ encode_int(self.hero_log_property3_value2) \
|
|
+ encode_int(self.hero_log_property4_property_id) \
|
|
+ encode_int(self.hero_log_property4_value1) \
|
|
+ encode_int(self.hero_log_property4_value2) \
|
|
+ encode_int(self.main_weapon_equipment_id) \
|
|
+ encode_short(self.main_weapon_enhancement_value) \
|
|
+ encode_short(self.main_weapon_awakening_stage) \
|
|
+ encode_int(self.main_weapon_property1_property_id) \
|
|
+ encode_int(self.main_weapon_property1_value1) \
|
|
+ encode_int(self.main_weapon_property1_value2) \
|
|
+ encode_int(self.main_weapon_property2_property_id) \
|
|
+ encode_int(self.main_weapon_property2_value1) \
|
|
+ encode_int(self.main_weapon_property2_value2) \
|
|
+ encode_int(self.main_weapon_property3_property_id) \
|
|
+ encode_int(self.main_weapon_property3_value1) \
|
|
+ encode_int(self.main_weapon_property3_value2) \
|
|
+ encode_int(self.main_weapon_property4_property_id) \
|
|
+ encode_int(self.main_weapon_property4_value1) \
|
|
+ encode_int(self.main_weapon_property4_value2) \
|
|
+ encode_int(self.sub_equipment_equipment_id) \
|
|
+ encode_short(self.sub_equipment_enhancement_value) \
|
|
+ encode_short(self.sub_equipment_awakening_stage) \
|
|
+ encode_int(self.sub_equipment_property1_property_id) \
|
|
+ encode_int(self.sub_equipment_property1_value1) \
|
|
+ encode_int(self.sub_equipment_property1_value2) \
|
|
+ encode_int(self.sub_equipment_property2_property_id) \
|
|
+ encode_int(self.sub_equipment_property2_value1) \
|
|
+ encode_int(self.sub_equipment_property2_value2) \
|
|
+ encode_int(self.sub_equipment_property3_property_id) \
|
|
+ encode_int(self.sub_equipment_property3_value1) \
|
|
+ encode_int(self.sub_equipment_property3_value2) \
|
|
+ encode_int(self.sub_equipment_property4_property_id) \
|
|
+ encode_int(self.sub_equipment_property4_value1) \
|
|
+ encode_int(self.sub_equipment_property4_value2) \
|
|
+ encode_short(self.skill_slot1_skill_id) \
|
|
+ encode_short(self.skill_slot2_skill_id) \
|
|
+ encode_short(self.skill_slot3_skill_id) \
|
|
+ encode_short(self.skill_slot4_skill_id) \
|
|
+ encode_short(self.skill_slot5_skill_id)
|
|
|
|
class DefragMatchCpuSupportLogData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_cpu_support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_start_defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_end_defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_start_class_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.appearance_end_class_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.support_log_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.awakening_stage = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchCpuSupportLogData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_cpu_support_log_id = data['DefragMatchCpuSupportLogId']
|
|
ret.appearance_start_defrag_match_id = data['AppearanceStartDefragMatchId']
|
|
ret.appearance_end_defrag_match_id = data['AppearanceEndDefragMatchId']
|
|
ret.appearance_start_class_num = data['AppearanceStartClassNum']
|
|
ret.appearance_end_class_num = data['AppearanceEndClassNum']
|
|
ret.support_log_id = data['SupportLogId']
|
|
ret.awakening_stage = data['AwakeningStage']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_cpu_support_log_id) \
|
|
+ encode_int(self.appearance_start_defrag_match_id) \
|
|
+ encode_int(self.appearance_end_defrag_match_id) \
|
|
+ encode_int(self.appearance_start_class_num) \
|
|
+ encode_int(self.appearance_end_class_num) \
|
|
+ encode_int(self.support_log_id) \
|
|
+ encode_short(self.awakening_stage)
|
|
|
|
class DefragMatchPeriodBonusData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_period_bonus_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.bonus_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.param_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchPeriodBonusData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_period_bonus_id = data['DefragMatchPeriodBonusId']
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.bonus_type = data['BonusType']
|
|
ret.param_1 = data['Param1']
|
|
ret.param_2 = data['Param2']
|
|
ret.param_3 = data['Param3']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_period_bonus_id) \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_byte(self.bonus_type) \
|
|
+ encode_str(self.param_1) \
|
|
+ encode_str(self.param_2) \
|
|
+ encode_str(self.param_3) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class DefragMatchRandomBonusTableData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_random_bonus_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_random_bonus_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.condition_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_league_point = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.random_bonus_num = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchRandomBonusTableData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_random_bonus_id = data['DefragMatchRandomBonusId']
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.defrag_match_random_bonus_condition_id = data['DefragMatchRandomBonusConditionId']
|
|
ret.name = data['Name']
|
|
ret.condition_value1 = data['ConditionValue1']
|
|
ret.condition_value2 = data['ConditionValue2']
|
|
ret.get_league_point = data['GetLeaguePoint']
|
|
ret.random_bonus_num = data['RandomBonusNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_random_bonus_id) \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_int(self.defrag_match_random_bonus_condition_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_int(self.condition_value1) \
|
|
+ encode_int(self.condition_value2) \
|
|
+ encode_int(self.get_league_point) \
|
|
+ encode_byte(self.random_bonus_num)
|
|
|
|
class DefragMatchRandomBonusConditionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_random_bonus_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.hud_format, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.format_param_size = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchRandomBonusConditionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_random_bonus_condition_id = data['DefragMatchRandomBonusConditionId']
|
|
ret.format = data['Format']
|
|
ret.hud_format = data['HudFormat']
|
|
ret.format_param_size = data['FormatParamSize']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_random_bonus_condition_id) \
|
|
+ encode_str(self.format) \
|
|
+ encode_str(self.hud_format) \
|
|
+ encode_int(self.format_param_size)
|
|
|
|
class DefragMatchRareDropData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.defrag_match_rare_drop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.defrag_match_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_min = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.strength_max = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property_table_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.drop_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "DefragMatchRareDropData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.defrag_match_rare_drop_id = data['DefragMatchRareDropId']
|
|
ret.defrag_match_id = data['DefragMatchId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength_min = data['StrengthMin']
|
|
ret.strength_max = data['StrengthMax']
|
|
ret.property_table_sub_id = data['PropertyTableSubId']
|
|
ret.drop_rate = data['DropRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.defrag_match_rare_drop_id) \
|
|
+ encode_int(self.defrag_match_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_int(self.common_reward_num) \
|
|
+ encode_int(self.strength_min) \
|
|
+ encode_int(self.strength_max) \
|
|
+ encode_int(self.property_table_sub_id) \
|
|
+ encode_str(self.drop_rate)
|
|
|
|
class YuiMedalShopData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.yui_medal_shop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.description, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.selling_yui_medal = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.selling_col = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.selling_event_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.selling_event_item_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.selling_ticket_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.purchase_limit = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.pick_up_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.product_category = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.sales_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.target_days = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.target_hour = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.interval_hour = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.sales_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.sales_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.sort = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "YuiMedalShopData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.yui_medal_shop_id = data['YuiMedalShopId']
|
|
ret.name = data['Name']
|
|
ret.description = data['Description']
|
|
ret.selling_yui_medal = data['SellingYuiMedal']
|
|
ret.selling_col = data['SellingCol']
|
|
ret.selling_event_item_id = data['SellingEventItemId']
|
|
ret.selling_event_item_num = data['SellingEventItemNum']
|
|
ret.selling_ticket_num = data['SellingTicketNum']
|
|
ret.purchase_limit = data['PurchaseLimit']
|
|
ret.pick_up_flag = data['PickUpFlag']
|
|
ret.product_category = data['ProductCategory']
|
|
ret.sales_type = data['SalesType']
|
|
ret.target_days = data['TargetDays']
|
|
ret.target_hour = data['TargetHour']
|
|
ret.interval_hour = data['IntervalHour']
|
|
ret.sales_start_date = data['SalesStartDate']
|
|
ret.sales_end_date = data['SalesEndDate']
|
|
ret.sort = data['Sort']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.yui_medal_shop_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.description) \
|
|
+ encode_short(self.selling_yui_medal) \
|
|
+ encode_int(self.selling_col) \
|
|
+ encode_int(self.selling_event_item_id) \
|
|
+ encode_int(self.selling_event_item_num) \
|
|
+ encode_int(self.selling_ticket_num) \
|
|
+ encode_short(self.purchase_limit) \
|
|
+ encode_byte(self.pick_up_flag) \
|
|
+ encode_byte(self.product_category) \
|
|
+ encode_byte(self.sales_type) \
|
|
+ encode_byte(self.target_days) \
|
|
+ encode_byte(self.target_hour) \
|
|
+ encode_byte(self.interval_hour) \
|
|
+ encode_date_str(self.sales_start_date) \
|
|
+ encode_date_str(self.sales_end_date) \
|
|
+ encode_byte(self.sort)
|
|
|
|
class YuiMedalShopItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.yui_medal_shop_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.yui_medal_shop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "YuiMedalShopItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.yui_medal_shop_item_id = data['YuiMedalShopItemId']
|
|
ret.yui_medal_shop_id = data['YuiMedalShopId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.yui_medal_shop_item_id) \
|
|
+ encode_int(self.yui_medal_shop_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class EventSceneData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.event_scene_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.event_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.scene_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.episode_no = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.param_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.adv_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EventSceneData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.event_scene_id = data['EventSceneId']
|
|
ret.event_id = data['EventId']
|
|
ret.scene_type = data['SceneType']
|
|
ret.episode_no = data['EpisodeNo']
|
|
ret.title = data['Title']
|
|
ret.param_1 = data['Param1']
|
|
ret.param_2 = data['Param2']
|
|
ret.param_3 = data['Param3']
|
|
ret.adv_name = data['AdvName']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.event_scene_id) \
|
|
+ encode_int(self.event_id) \
|
|
+ encode_byte(self.scene_type) \
|
|
+ encode_int(self.episode_no) \
|
|
+ encode_str(self.title) \
|
|
+ encode_str(self.param_1) \
|
|
+ encode_str(self.param_2) \
|
|
+ encode_str(self.param_3) \
|
|
+ encode_str(self.adv_name)
|
|
|
|
class GenericCampaignPeriodData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.generic_campaign_period_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GenericCampaignPeriodData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.generic_campaign_period_id = data['GenericCampaignPeriodId']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.generic_campaign_period_id) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class BeginnerMissionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_id = data['BeginnerMissionId']
|
|
ret.name = data['Name']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class BeginnerMissionConditionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.beginner_mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.seat_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.mission_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.display_content, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.display_tips, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_param_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_param_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_param_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.required_achievement_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionConditionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_condition_id = data['BeginnerMissionConditionId']
|
|
ret.beginner_mission_id = data['BeginnerMissionId']
|
|
ret.seat_num = data['SeatNum']
|
|
ret.mission_num = data['MissionNum']
|
|
ret.display_content = data['DisplayContent']
|
|
ret.display_tips = data['DisplayTips']
|
|
ret.condition_type = data['ConditionType']
|
|
ret.condition_param_1 = data['ConditionParam1']
|
|
ret.condition_param_2 = data['ConditionParam2']
|
|
ret.condition_param_3 = data['ConditionParam3']
|
|
ret.required_achievement_num = data['RequiredAchievementNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_condition_id) \
|
|
+ encode_int(self.beginner_mission_id) \
|
|
+ encode_short(self.seat_num) \
|
|
+ encode_short(self.mission_num) \
|
|
+ encode_str(self.display_content) \
|
|
+ encode_str(self.display_tips) \
|
|
+ encode_byte(self.condition_type) \
|
|
+ encode_str(self.condition_param_1) \
|
|
+ encode_str(self.condition_param_2) \
|
|
+ encode_str(self.condition_param_3) \
|
|
+ encode_short(self.required_achievement_num)
|
|
|
|
class BeginnerMissionRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.beginner_mission_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_id = data['BeginnerMissionId']
|
|
ret.beginner_mission_condition_id = data['BeginnerMissionConditionId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_id) \
|
|
+ encode_int(self.beginner_mission_condition_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class BeginnerMissionSeatConditionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.beginner_mission_seat_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.seat_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.mission_seat_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.display_content, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.display_tips, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.condition_param_1, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_param_2, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.condition_param_3, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.required_achievement_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionSeatConditionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_id = data['BeginnerMissionId']
|
|
ret.beginner_mission_seat_condition_id = data['BeginnerMissionSeatConditionId']
|
|
ret.seat_num = data['SeatNum']
|
|
ret.mission_seat_num = data['MissionSeatNum']
|
|
ret.display_content = data['DisplayContent']
|
|
ret.display_tips = data['DisplayTips']
|
|
ret.condition_type = data['ConditionType']
|
|
ret.condition_param_1 = data['ConditionParam1']
|
|
ret.condition_param_2 = data['ConditionParam2']
|
|
ret.condition_param_3 = data['ConditionParam3']
|
|
ret.required_achievement_num = data['RequiredAchievementNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_id) \
|
|
+ encode_int(self.beginner_mission_seat_condition_id) \
|
|
+ encode_short(self.seat_num) \
|
|
+ encode_short(self.mission_seat_num) \
|
|
+ encode_str(self.display_content) \
|
|
+ encode_str(self.display_tips) \
|
|
+ encode_byte(self.condition_type) \
|
|
+ encode_str(self.condition_param_1) \
|
|
+ encode_str(self.condition_param_2) \
|
|
+ encode_str(self.condition_param_3) \
|
|
+ encode_short(self.required_achievement_num)
|
|
|
|
class BeginnerMissionSeatRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.beginner_mission_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.beginner_mission_seat_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "BeginnerMissionSeatRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.beginner_mission_id = data['BeginnerMissionId']
|
|
ret.beginner_mission_seat_condition_id = data['BeginnerMissionSeatConditionId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.beginner_mission_id) \
|
|
+ encode_int(self.beginner_mission_seat_condition_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class EventItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.event_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.flavor_text, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.event_item_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EventItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.event_item_id = data['EventItemId']
|
|
ret.name = data['Name']
|
|
ret.flavor_text = data['FlavorText']
|
|
ret.event_item_icon = data['EventItemIcon']
|
|
ret.unit_id = data['UnitId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.event_item_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.flavor_text) \
|
|
+ encode_str(self.event_item_icon) \
|
|
+ encode_int(self.unit_id)
|
|
|
|
class EventMonsterData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.event_monster_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.event_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.unit_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.event_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.drop_rate, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "EventMonsterData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.event_monster_id = data['EventMonsterId']
|
|
ret.event_id = data['EventId']
|
|
ret.unit_id = data['UnitId']
|
|
ret.event_item_id = data['EventItemId']
|
|
ret.drop_rate = data['DropRate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.event_monster_id) \
|
|
+ encode_int(self.event_id) \
|
|
+ encode_int(self.unit_id) \
|
|
+ encode_int(self.event_item_id) \
|
|
+ encode_str(self.drop_rate)
|
|
|
|
class YuiMedalBonusData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.yui_medal_bonus_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "YuiMedalBonusData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.yui_medal_bonus_id = data['YuiMedalBonusId']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.yui_medal_bonus_id) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class YuiMedalBonusConditionData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.yui_medal_bonus_condition_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.yui_medal_bonus_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.target_days = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.get_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.loop_flag = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "YuiMedalBonusConditionData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.yui_medal_bonus_condition_id = data['YuiMedalBonusConditionId']
|
|
ret.yui_medal_bonus_id = data['YuiMedalBonusId']
|
|
ret.target_days = data['TargetDays']
|
|
ret.get_num = data['GetNum']
|
|
ret.loop_flag = data['LoopFlag']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.yui_medal_bonus_condition_id) \
|
|
+ encode_int(self.yui_medal_bonus_id) \
|
|
+ encode_int(self.target_days) \
|
|
+ encode_int(self.get_num) \
|
|
+ encode_byte(self.loop_flag)
|
|
|
|
class GashaMedalData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_medal_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_medal_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_medal_id = data['GashaMedalId']
|
|
ret.gasha_medal_type = data['GashaMedalType']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_medal_id) \
|
|
+ encode_byte(self.gasha_medal_type)
|
|
|
|
class GashaMedalTypeData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_medal_type = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.medal_icon, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalTypeData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_medal_type = data['GashaMedalType']
|
|
ret.name = data['Name']
|
|
ret.medal_icon = data['MedalIcon']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_medal_type) \
|
|
+ encode_str(self.name) \
|
|
+ encode_str(self.medal_icon)
|
|
|
|
class GashaMedalSettingData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_medal_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalSettingData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_id = data['GashaId']
|
|
ret.gasha_medal_id = data['GashaMedalId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_id) \
|
|
+ encode_int(self.gasha_medal_id)
|
|
|
|
class GashaMedalBonusData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.analyze_amount = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.get_gasha_medal_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalBonusData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.analyze_amount = data['AnalyzeAmount']
|
|
ret.get_gasha_medal_num = data['GetGashaMedalNum']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_byte(self.analyze_amount) \
|
|
+ encode_int(self.get_gasha_medal_num) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class GashaMedalShopData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_medal_shop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.gasha_medal_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.use_gasha_medal_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.purchase_limit = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalShopData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_medal_shop_id = data['GashaMedalShopId']
|
|
ret.name = data['Name']
|
|
ret.gasha_medal_id = data['GashaMedalId']
|
|
ret.use_gasha_medal_num = data['UseGashaMedalNum']
|
|
ret.purchase_limit = data['PurchaseLimit']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_medal_shop_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_int(self.gasha_medal_id) \
|
|
+ encode_int(self.use_gasha_medal_num) \
|
|
+ encode_short(self.purchase_limit) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class GashaMedalShopItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_medal_shop_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.gasha_medal_shop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaMedalShopItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_medal_shop_item_id = data['GashaMedalShopItemId']
|
|
ret.gasha_medal_shop_id = data['GashaMedalShopId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_medal_shop_item_id) \
|
|
+ encode_int(self.gasha_medal_shop_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class ResEarnCampaignApplicationData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.res_earn_campaign_application_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.news_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.help_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ResEarnCampaignApplicationData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.res_earn_campaign_application_id = data['ResEarnCampaignApplicationId']
|
|
ret.title = data['Title']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
ret.posting_start_date = data['PostingStartDate']
|
|
ret.posting_end_date = data['PostingEndDate']
|
|
ret.news_id = data['NewsId']
|
|
ret.help_id = data['HelpId']
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.res_earn_campaign_application_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date) \
|
|
+ encode_date_str(self.posting_start_date) \
|
|
+ encode_date_str(self.posting_end_date) \
|
|
+ encode_str(self.news_id) \
|
|
+ encode_int(self.help_id) \
|
|
+ encode_int(self.ad_banner_id)
|
|
|
|
class ResEarnCampaignApplicationProductData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.res_earn_campaign_application_product_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.res_earn_campaign_application_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.award_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.need_application_point = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.winning_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ResEarnCampaignApplicationProductData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.res_earn_campaign_application_product_id = data['ResEarnCampaignApplicationProductId']
|
|
ret.res_earn_campaign_application_id = data['ResEarnCampaignApplicationId']
|
|
ret.award_name = data['AwardName']
|
|
ret.name = data['Name']
|
|
ret.need_application_point = data['NeedApplicationPoint']
|
|
ret.winning_num = data['WinningNum']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.res_earn_campaign_application_product_id) \
|
|
+ encode_int(self.res_earn_campaign_application_id) \
|
|
+ encode_str(self.award_name) \
|
|
+ encode_str(self.name) \
|
|
+ encode_short(self.need_application_point) \
|
|
+ encode_short(self.winning_num)
|
|
|
|
class ResEarnCampaignShopData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.res_earn_campaign_shop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.res_earn_campaign_application_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.selling_yui_medal = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.selling_col = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.selling_event_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.selling_event_item_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.purchase_limit = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.get_application_point = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ResEarnCampaignShopData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.res_earn_campaign_shop_id = data['ResEarnCampaignShopId']
|
|
ret.res_earn_campaign_application_id = data['ResEarnCampaignApplicationId']
|
|
ret.name = data['Name']
|
|
ret.selling_yui_medal = data['SellingYuiMedal']
|
|
ret.selling_col = data['SellingCol']
|
|
ret.selling_event_item_id = data['SellingEventItemId']
|
|
ret.selling_event_item_num = data['SellingEventItemNum']
|
|
ret.purchase_limit = data['PurchaseLimit']
|
|
ret.get_application_point = data['GetApplicationPoint']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.res_earn_campaign_shop_id) \
|
|
+ encode_int(self.res_earn_campaign_application_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_short(self.selling_yui_medal) \
|
|
+ encode_int(self.selling_col) \
|
|
+ encode_int(self.selling_event_item_id) \
|
|
+ encode_int(self.selling_event_item_num) \
|
|
+ encode_short(self.purchase_limit) \
|
|
+ encode_short(self.get_application_point) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class ResEarnCampaignShopItemData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.res_earn_campaign_shop_item_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.res_earn_campaign_shop_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "ResEarnCampaignShopItemData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.res_earn_campaign_shop_item_id = data['ResEarnCampaignShopItemId']
|
|
ret.res_earn_campaign_shop_id = data['ResEarnCampaignShopId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.res_earn_campaign_shop_item_id) \
|
|
+ encode_int(self.res_earn_campaign_shop_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class PayingYuiMedalBonusData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.paying_yui_medal_bonus_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.reward_yui_medal_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.news_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.help_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PayingYuiMedalBonusData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.paying_yui_medal_bonus_id = data['PayingYuiMedalBonusId']
|
|
ret.title = data['Title']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
ret.reward_yui_medal_num = data['RewardYuiMedalNum']
|
|
ret.news_id = data['NewsId']
|
|
ret.help_id = data['HelpId']
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.paying_yui_medal_bonus_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date) \
|
|
+ encode_int(self.reward_yui_medal_num) \
|
|
+ encode_str(self.news_id) \
|
|
+ encode_int(self.help_id) \
|
|
+ encode_int(self.ad_banner_id)
|
|
|
|
class AcLoginBonusData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.ac_login_bonus_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.reward_set_sub_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "AcLoginBonusData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.ac_login_bonus_id = data['AcLoginBonusId']
|
|
ret.title = data['Title']
|
|
ret.reward_set_sub_id = data['RewardSetSubId']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.ac_login_bonus_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_int(self.reward_set_sub_id) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date)
|
|
|
|
class PlayCampaignData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.play_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.campaign_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.news_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.help_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PlayCampaignData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.play_campaign_id = data['PlayCampaignId']
|
|
ret.title = data['Title']
|
|
ret.campaign_type = data['CampaignType']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
ret.posting_start_date = data['PostingStartDate']
|
|
ret.posting_end_date = data['PostingEndDate']
|
|
ret.news_id = data['NewsId']
|
|
ret.help_id = data['HelpId']
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.play_campaign_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_byte(self.campaign_type) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date) \
|
|
+ encode_date_str(self.posting_start_date) \
|
|
+ encode_date_str(self.posting_end_date) \
|
|
+ encode_str(self.news_id) \
|
|
+ encode_int(self.help_id) \
|
|
+ encode_int(self.ad_banner_id)
|
|
|
|
class PlayCampaignRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.play_campaign_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.play_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.product_no = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.product_name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.product_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.resource_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.required_credit_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "PlayCampaignRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.play_campaign_reward_id = data['PlayCampaignRewardId']
|
|
ret.play_campaign_id = data['PlayCampaignId']
|
|
ret.product_no = data['ProductNo']
|
|
ret.product_name = data['ProductName']
|
|
ret.product_type = data['ProductType']
|
|
ret.resource_type = data['ResourceType']
|
|
ret.required_credit_num = data['RequiredCreditNum']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
ret.title_id = data['TitleId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.play_campaign_reward_id) \
|
|
+ encode_int(self.play_campaign_id) \
|
|
+ encode_int(self.product_no) \
|
|
+ encode_str(self.product_name) \
|
|
+ encode_byte(self.product_type) \
|
|
+ encode_byte(self.resource_type) \
|
|
+ encode_int(self.required_credit_num) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2) \
|
|
+ encode_int(self.title_id)
|
|
|
|
class GashaFreeCampaignData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.gasha_free_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "GashaFreeCampaignData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.gasha_free_campaign_id = data['GashaFreeCampaignId']
|
|
ret.name = data['Name']
|
|
ret.start_date = data['StartDate']
|
|
ret.end_date = data['EndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.gasha_free_campaign_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_date_str(self.start_date) \
|
|
+ encode_date_str(self.end_date)
|
|
|
|
class QuestDropBoostCampaignData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.quest_drop_boost_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.name, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.consume_ticket_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.drop_magnification = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "QuestDropBoostCampaignData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.quest_drop_boost_campaign_id = data['QuestDropBoostCampaignId']
|
|
ret.name = data['Name']
|
|
ret.consume_ticket_num = data['ConsumeTicketNum']
|
|
ret.drop_magnification = data['DropMagnification']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.quest_drop_boost_campaign_id) \
|
|
+ encode_str(self.name) \
|
|
+ encode_int(self.consume_ticket_num) \
|
|
+ encode_byte(self.drop_magnification) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date)
|
|
|
|
class FirstTicketPurchaseCampaignData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.first_ticket_purchase_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.not_target_applying_base_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.target_ticket_purchase_id_list, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.news_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.help_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "FirstTicketPurchaseCampaignData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.first_ticket_purchase_campaign_id = data['FirstTicketPurchaseCampaignId']
|
|
ret.title = data['Title']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
ret.not_target_applying_base_date = data['NotTargetApplyingBaseDate']
|
|
ret.target_ticket_purchase_id_list = data['TargetTicketPurchaseIdList']
|
|
ret.news_id = data['NewsId']
|
|
ret.help_id = data['HelpId']
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.first_ticket_purchase_campaign_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date) \
|
|
+ encode_date_str(self.not_target_applying_base_date) \
|
|
+ encode_str(self.target_ticket_purchase_id_list) \
|
|
+ encode_str(self.news_id) \
|
|
+ encode_int(self.help_id) \
|
|
+ encode_int(self.ad_banner_id)
|
|
|
|
class LinkedSiteRegCampaignsData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.linked_site_reg_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.title, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.open_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_start_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.posting_end_date, new_off = decode_date_str(data, off)
|
|
off += new_off
|
|
|
|
self.news_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.help_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.ad_banner_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "LinkedSiteRegCampaignsData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.linked_site_reg_campaign_id = data['LinkedSiteRegCampaignId']
|
|
ret.title = data['Title']
|
|
ret.open_start_date = data['OpenStartDate']
|
|
ret.open_end_date = data['OpenEndDate']
|
|
ret.posting_start_date = data['PostingStartDate']
|
|
ret.posting_end_date = data['PostingEndDate']
|
|
ret.news_id = data['NewsId']
|
|
ret.help_id = data['HelpId']
|
|
ret.ad_banner_id = data['AdBannerId']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.linked_site_reg_campaign_id) \
|
|
+ encode_str(self.title) \
|
|
+ encode_date_str(self.open_start_date) \
|
|
+ encode_date_str(self.open_end_date) \
|
|
+ encode_date_str(self.posting_start_date) \
|
|
+ encode_date_str(self.posting_end_date) \
|
|
+ encode_str(self.news_id) \
|
|
+ encode_int(self.help_id) \
|
|
+ encode_int(self.ad_banner_id)
|
|
|
|
class LinkedSiteRegCampaignRewardData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.linked_site_reg_campaign_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.linked_site_reg_campaign_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_type = decode_byte(data, off)
|
|
off += BYTE_OFF
|
|
|
|
self.common_reward_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.common_reward_num = decode_short(data, off)
|
|
off += SHORT_OFF
|
|
|
|
self.strength = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property1_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property2_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property3_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_property_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value1 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.property4_value2 = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, data: Dict) -> "LinkedSiteRegCampaignRewardData":
|
|
ret = cls(b"\x00" * 99, 0)
|
|
ret.linked_site_reg_campaign_reward_id = data['LinkedSiteRegCampaignRewardId']
|
|
ret.linked_site_reg_campaign_id = data['LinkedSiteRegCampaignId']
|
|
ret.common_reward_type = data['CommonRewardType']
|
|
ret.common_reward_id = data['CommonRewardId']
|
|
ret.common_reward_num = data['CommonRewardNum']
|
|
ret.strength = data['Strength']
|
|
ret.property1_property_id = data['Property1PropertyId']
|
|
ret.property1_value1 = data['Property1Value1']
|
|
ret.property1_value2 = data['Property1Value2']
|
|
ret.property2_property_id = data['Property2PropertyId']
|
|
ret.property2_value1 = data['Property2Value1']
|
|
ret.property2_value2 = data['Property2Value2']
|
|
ret.property3_property_id = data['Property3PropertyId']
|
|
ret.property3_value1 = data['Property3Value1']
|
|
ret.property3_value2 = data['Property3Value2']
|
|
ret.property4_property_id = data['Property4PropertyId']
|
|
ret.property4_value1 = data['Property4Value1']
|
|
ret.property4_value2 = data['Property4Value2']
|
|
return ret
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_int(self.linked_site_reg_campaign_reward_id) \
|
|
+ encode_int(self.linked_site_reg_campaign_id) \
|
|
+ encode_byte(self.common_reward_type) \
|
|
+ encode_int(self.common_reward_id) \
|
|
+ encode_short(self.common_reward_num) \
|
|
+ encode_int(self.strength) \
|
|
+ encode_int(self.property1_property_id) \
|
|
+ encode_int(self.property1_value1) \
|
|
+ encode_int(self.property1_value2) \
|
|
+ encode_int(self.property2_property_id) \
|
|
+ encode_int(self.property2_value1) \
|
|
+ encode_int(self.property2_value2) \
|
|
+ encode_int(self.property3_property_id) \
|
|
+ encode_int(self.property3_value1) \
|
|
+ encode_int(self.property3_value2) \
|
|
+ encode_int(self.property4_property_id) \
|
|
+ encode_int(self.property4_value1) \
|
|
+ encode_int(self.property4_value2)
|
|
|
|
class EpisodeAppendUserData(BaseHelper):
|
|
def __init__(self, data: bytes, offset: int):
|
|
off = offset
|
|
self.user_episode_append_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.user_id, new_off = decode_str(data, off)
|
|
off += new_off
|
|
|
|
self.episode_append_id = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self.own_num = decode_int(data, off)
|
|
off += INT_OFF
|
|
|
|
self._sz = off - offset
|
|
|
|
@classmethod
|
|
def from_args(cls, episode_id: int = 0, user_id: int = 0, episode_append_id: int = 0, own_num: int = 99) -> "EpisodeAppendUserData":
|
|
ret = cls(b"\x00" * 996, 0)
|
|
ret.user_episode_append_id = episode_id
|
|
ret.user_id = user_id
|
|
ret.episode_append_id = episode_append_id
|
|
ret.own_num = own_num
|
|
|
|
def make(self) -> bytes:
|
|
return super().make() \
|
|
+ encode_str(self.user_episode_append_id) \
|
|
+ encode_str(self.user_id) \
|
|
+ encode_int(self.episode_append_id) \
|
|
+ encode_int(self.own_num)
|