code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct18(BaseProperty):
slave_platform_motion_knots: bool = dataclasses.field(default=False)
slave_position_in_local_space: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b':h\xee\\') # 0x3a68ee5c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.slave_platform_motion_knots))
data.write(b'D\xb31\xec') # 0x44b331ec
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.slave_position_in_local_space))
@classmethod
def from_json(cls, data: dict):
return cls(
slave_platform_motion_knots=data['slave_platform_motion_knots'],
slave_position_in_local_space=data['slave_position_in_local_space'],
)
def to_json(self) -> dict:
return {
'slave_platform_motion_knots': self.slave_platform_motion_knots,
'slave_position_in_local_space': self.slave_position_in_local_space,
}
_FAST_FORMAT = None
_FAST_IDS = (0x3a68ee5c, 0x44b331ec)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct18]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(14))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct18(
dec[2],
dec[5],
)
def _decode_slave_platform_motion_knots(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_slave_position_in_local_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x3a68ee5c: ('slave_platform_motion_knots', _decode_slave_platform_motion_knots),
0x44b331ec: ('slave_position_in_local_space', _decode_slave_position_in_local_space),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct18.py | 0.593727 | 0.287611 | UnknownStruct18.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class HurlHeightRules(BaseProperty):
number_of_hurl_heights: int = dataclasses.field(default=0)
hurl_height1: float = dataclasses.field(default=1.0)
hurl_height2: float = dataclasses.field(default=2.0)
hurl_height3: float = dataclasses.field(default=3.0)
hurl_height4: float = dataclasses.field(default=4.0)
hurl_height5: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'!\x87\xc1~') # 0x2187c17e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_hurl_heights))
data.write(b'=.\xa7`') # 0x3d2ea760
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_height1))
data.write(b'\xbb\xba\xd5\xce') # 0xbbbad5ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_height2))
data.write(b'p\xe6\x06k') # 0x70e6066b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_height3))
data.write(b'm\xe36\xd3') # 0x6de336d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_height4))
data.write(b'\xa6\xbf\xe5v') # 0xa6bfe576
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_height5))
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_hurl_heights=data['number_of_hurl_heights'],
hurl_height1=data['hurl_height1'],
hurl_height2=data['hurl_height2'],
hurl_height3=data['hurl_height3'],
hurl_height4=data['hurl_height4'],
hurl_height5=data['hurl_height5'],
)
def to_json(self) -> dict:
return {
'number_of_hurl_heights': self.number_of_hurl_heights,
'hurl_height1': self.hurl_height1,
'hurl_height2': self.hurl_height2,
'hurl_height3': self.hurl_height3,
'hurl_height4': self.hurl_height4,
'hurl_height5': self.hurl_height5,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2187c17e, 0x3d2ea760, 0xbbbad5ce, 0x70e6066b, 0x6de336d3, 0xa6bfe576)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HurlHeightRules]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(60))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return HurlHeightRules(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_number_of_hurl_heights(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_hurl_height1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_height2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_height3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_height4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_height5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2187c17e: ('number_of_hurl_heights', _decode_number_of_hurl_heights),
0x3d2ea760: ('hurl_height1', _decode_hurl_height1),
0xbbbad5ce: ('hurl_height2', _decode_hurl_height2),
0x70e6066b: ('hurl_height3', _decode_hurl_height3),
0x6de336d3: ('hurl_height4', _decode_hurl_height4),
0xa6bfe576: ('hurl_height5', _decode_hurl_height5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/HurlHeightRules.py | 0.608012 | 0.254521 | HurlHeightRules.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct191(BaseProperty):
unknown_0x8a58a7f8: int = dataclasses.field(default=1)
initial_launch_delay: float = dataclasses.field(default=1.0)
launch_delay: float = dataclasses.field(default=1.0)
unknown_0xe828e54e: float = dataclasses.field(default=6.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'\xcc\xa8\xaf=') # 0xcca8af3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_launch_delay))
data.write(b'FU\xa9\xc5') # 0x4655a9c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.launch_delay))
data.write(b'\xe8(\xe5N') # 0xe828e54e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe828e54e))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
initial_launch_delay=data['initial_launch_delay'],
launch_delay=data['launch_delay'],
unknown_0xe828e54e=data['unknown_0xe828e54e'],
)
def to_json(self) -> dict:
return {
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'initial_launch_delay': self.initial_launch_delay,
'launch_delay': self.launch_delay,
'unknown_0xe828e54e': self.unknown_0xe828e54e,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8a58a7f8, 0xcca8af3d, 0x4655a9c5, 0xe828e54e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct191]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct191(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_initial_launch_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_launch_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe828e54e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0xcca8af3d: ('initial_launch_delay', _decode_initial_launch_delay),
0x4655a9c5: ('launch_delay', _decode_launch_delay),
0xe828e54e: ('unknown_0xe828e54e', _decode_unknown_0xe828e54e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct191.py | 0.593963 | 0.258104 | UnknownStruct191.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct254 import UnknownStruct254
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct255 import UnknownStruct255
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct257 import UnknownStruct257
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct258 import UnknownStruct258
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct259(BaseProperty):
snap_to_spline: bool = dataclasses.field(default=True)
gravity: float = dataclasses.field(default=55.0)
unknown_0xee382651: float = dataclasses.field(default=0.30000001192092896)
unknown_0x46b65220: float = dataclasses.field(default=3.0)
unknown_0xab417b5d: float = dataclasses.field(default=6.0)
unknown_0x0f4cb02a: float = dataclasses.field(default=0.20000000298023224)
unknown_0x396bedd2: float = dataclasses.field(default=12.0)
unknown_0xe564f7b4: float = dataclasses.field(default=0.10000000149011612)
unknown_0x8699ac03: float = dataclasses.field(default=4.0)
unknown_0x663174bc: float = dataclasses.field(default=1.0)
ground_pound_window: float = dataclasses.field(default=0.20000000298023224)
ground_pound_relapse_multiplier: float = dataclasses.field(default=1.0)
unknown_0xcdeaba73: float = dataclasses.field(default=0.10000000149011612)
grid_size: float = dataclasses.field(default=2.5)
grid_count: int = dataclasses.field(default=12)
unknown_0x2144c2e2: float = dataclasses.field(default=1.0)
unknown_0xc9292d7b: int = dataclasses.field(default=0)
unknown_0x12cbcdb4: bool = dataclasses.field(default=False)
render_push_amount: float = dataclasses.field(default=0.0)
unknown_0xcb065ea2: bool = dataclasses.field(default=False)
additive_state_machine: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
unknown_0x06435aff: int = dataclasses.field(default=0)
unknown_0xb073b311: int = dataclasses.field(default=0)
unknown_0x719345cf: int = dataclasses.field(default=0)
spike_move_speed: float = dataclasses.field(default=12.0)
unknown_0x0483a338: int = dataclasses.field(default=0)
unknown_struct254: UnknownStruct254 = dataclasses.field(default_factory=UnknownStruct254)
unknown_struct255: UnknownStruct255 = dataclasses.field(default_factory=UnknownStruct255)
unknown_struct257: UnknownStruct257 = dataclasses.field(default_factory=UnknownStruct257)
unknown_struct258: UnknownStruct258 = dataclasses.field(default_factory=UnknownStruct258)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1e') # 30 properties
data.write(b'&\xec\xb99') # 0x26ecb939
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.snap_to_spline))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xee8&Q') # 0xee382651
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xee382651))
data.write(b'F\xb6R ') # 0x46b65220
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x46b65220))
data.write(b'\xabA{]') # 0xab417b5d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xab417b5d))
data.write(b'\x0fL\xb0*') # 0xf4cb02a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0f4cb02a))
data.write(b'9k\xed\xd2') # 0x396bedd2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x396bedd2))
data.write(b'\xe5d\xf7\xb4') # 0xe564f7b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe564f7b4))
data.write(b'\x86\x99\xac\x03') # 0x8699ac03
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8699ac03))
data.write(b'f1t\xbc') # 0x663174bc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x663174bc))
data.write(b'h\xd7\x87\xb4') # 0x68d787b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_window))
data.write(b'hn\x03\x0b') # 0x686e030b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_relapse_multiplier))
data.write(b'\xcd\xea\xbas') # 0xcdeaba73
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcdeaba73))
data.write(b'\x90LCu') # 0x904c4375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grid_size))
data.write(b'\xe2\xae\xeb\xfb') # 0xe2aeebfb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.grid_count))
data.write(b'!D\xc2\xe2') # 0x2144c2e2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2144c2e2))
data.write(b'\xc9)-{') # 0xc9292d7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc9292d7b))
data.write(b'\x12\xcb\xcd\xb4') # 0x12cbcdb4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x12cbcdb4))
data.write(b'\xf4\x96\x80=') # 0xf496803d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push_amount))
data.write(b'\xcb\x06^\xa2') # 0xcb065ea2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcb065ea2))
data.write(b':\x98\x08\xcf') # 0x3a9808cf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.additive_state_machine))
data.write(b'\x06CZ\xff') # 0x6435aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x06435aff))
data.write(b'\xb0s\xb3\x11') # 0xb073b311
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xb073b311))
data.write(b'q\x93E\xcf') # 0x719345cf
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x719345cf))
data.write(b'[ <\xba') # 0x5b203cba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spike_move_speed))
data.write(b'\x04\x83\xa38') # 0x483a338
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x0483a338))
data.write(b'\xe0\xdc\xfb\xbe') # 0xe0dcfbbe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct254.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%@\xa6q') # 0x2540a671
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct255.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\xc2\xf8\xda') # 0xaac2f8da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct257.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xc3\xe3\xec') # 0x17c3e3ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct258.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
snap_to_spline=data['snap_to_spline'],
gravity=data['gravity'],
unknown_0xee382651=data['unknown_0xee382651'],
unknown_0x46b65220=data['unknown_0x46b65220'],
unknown_0xab417b5d=data['unknown_0xab417b5d'],
unknown_0x0f4cb02a=data['unknown_0x0f4cb02a'],
unknown_0x396bedd2=data['unknown_0x396bedd2'],
unknown_0xe564f7b4=data['unknown_0xe564f7b4'],
unknown_0x8699ac03=data['unknown_0x8699ac03'],
unknown_0x663174bc=data['unknown_0x663174bc'],
ground_pound_window=data['ground_pound_window'],
ground_pound_relapse_multiplier=data['ground_pound_relapse_multiplier'],
unknown_0xcdeaba73=data['unknown_0xcdeaba73'],
grid_size=data['grid_size'],
grid_count=data['grid_count'],
unknown_0x2144c2e2=data['unknown_0x2144c2e2'],
unknown_0xc9292d7b=data['unknown_0xc9292d7b'],
unknown_0x12cbcdb4=data['unknown_0x12cbcdb4'],
render_push_amount=data['render_push_amount'],
unknown_0xcb065ea2=data['unknown_0xcb065ea2'],
additive_state_machine=data['additive_state_machine'],
unknown_0x06435aff=data['unknown_0x06435aff'],
unknown_0xb073b311=data['unknown_0xb073b311'],
unknown_0x719345cf=data['unknown_0x719345cf'],
spike_move_speed=data['spike_move_speed'],
unknown_0x0483a338=data['unknown_0x0483a338'],
unknown_struct254=UnknownStruct254.from_json(data['unknown_struct254']),
unknown_struct255=UnknownStruct255.from_json(data['unknown_struct255']),
unknown_struct257=UnknownStruct257.from_json(data['unknown_struct257']),
unknown_struct258=UnknownStruct258.from_json(data['unknown_struct258']),
)
def to_json(self) -> dict:
return {
'snap_to_spline': self.snap_to_spline,
'gravity': self.gravity,
'unknown_0xee382651': self.unknown_0xee382651,
'unknown_0x46b65220': self.unknown_0x46b65220,
'unknown_0xab417b5d': self.unknown_0xab417b5d,
'unknown_0x0f4cb02a': self.unknown_0x0f4cb02a,
'unknown_0x396bedd2': self.unknown_0x396bedd2,
'unknown_0xe564f7b4': self.unknown_0xe564f7b4,
'unknown_0x8699ac03': self.unknown_0x8699ac03,
'unknown_0x663174bc': self.unknown_0x663174bc,
'ground_pound_window': self.ground_pound_window,
'ground_pound_relapse_multiplier': self.ground_pound_relapse_multiplier,
'unknown_0xcdeaba73': self.unknown_0xcdeaba73,
'grid_size': self.grid_size,
'grid_count': self.grid_count,
'unknown_0x2144c2e2': self.unknown_0x2144c2e2,
'unknown_0xc9292d7b': self.unknown_0xc9292d7b,
'unknown_0x12cbcdb4': self.unknown_0x12cbcdb4,
'render_push_amount': self.render_push_amount,
'unknown_0xcb065ea2': self.unknown_0xcb065ea2,
'additive_state_machine': self.additive_state_machine,
'unknown_0x06435aff': self.unknown_0x06435aff,
'unknown_0xb073b311': self.unknown_0xb073b311,
'unknown_0x719345cf': self.unknown_0x719345cf,
'spike_move_speed': self.spike_move_speed,
'unknown_0x0483a338': self.unknown_0x0483a338,
'unknown_struct254': self.unknown_struct254.to_json(),
'unknown_struct255': self.unknown_struct255.to_json(),
'unknown_struct257': self.unknown_struct257.to_json(),
'unknown_struct258': self.unknown_struct258.to_json(),
}
def _decode_snap_to_spline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xee382651(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x46b65220(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xab417b5d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0f4cb02a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x396bedd2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe564f7b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8699ac03(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x663174bc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_pound_window(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_pound_relapse_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcdeaba73(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grid_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grid_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2144c2e2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc9292d7b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x12cbcdb4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_push_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcb065ea2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_additive_state_machine(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x06435aff(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xb073b311(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x719345cf(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spike_move_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0483a338(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct254(data: typing.BinaryIO, property_size: int):
return UnknownStruct254.from_stream(data, property_size)
def _decode_unknown_struct255(data: typing.BinaryIO, property_size: int):
return UnknownStruct255.from_stream(data, property_size)
def _decode_unknown_struct257(data: typing.BinaryIO, property_size: int):
return UnknownStruct257.from_stream(data, property_size)
def _decode_unknown_struct258(data: typing.BinaryIO, property_size: int):
return UnknownStruct258.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x26ecb939: ('snap_to_spline', _decode_snap_to_spline),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xee382651: ('unknown_0xee382651', _decode_unknown_0xee382651),
0x46b65220: ('unknown_0x46b65220', _decode_unknown_0x46b65220),
0xab417b5d: ('unknown_0xab417b5d', _decode_unknown_0xab417b5d),
0xf4cb02a: ('unknown_0x0f4cb02a', _decode_unknown_0x0f4cb02a),
0x396bedd2: ('unknown_0x396bedd2', _decode_unknown_0x396bedd2),
0xe564f7b4: ('unknown_0xe564f7b4', _decode_unknown_0xe564f7b4),
0x8699ac03: ('unknown_0x8699ac03', _decode_unknown_0x8699ac03),
0x663174bc: ('unknown_0x663174bc', _decode_unknown_0x663174bc),
0x68d787b4: ('ground_pound_window', _decode_ground_pound_window),
0x686e030b: ('ground_pound_relapse_multiplier', _decode_ground_pound_relapse_multiplier),
0xcdeaba73: ('unknown_0xcdeaba73', _decode_unknown_0xcdeaba73),
0x904c4375: ('grid_size', _decode_grid_size),
0xe2aeebfb: ('grid_count', _decode_grid_count),
0x2144c2e2: ('unknown_0x2144c2e2', _decode_unknown_0x2144c2e2),
0xc9292d7b: ('unknown_0xc9292d7b', _decode_unknown_0xc9292d7b),
0x12cbcdb4: ('unknown_0x12cbcdb4', _decode_unknown_0x12cbcdb4),
0xf496803d: ('render_push_amount', _decode_render_push_amount),
0xcb065ea2: ('unknown_0xcb065ea2', _decode_unknown_0xcb065ea2),
0x3a9808cf: ('additive_state_machine', _decode_additive_state_machine),
0x6435aff: ('unknown_0x06435aff', _decode_unknown_0x06435aff),
0xb073b311: ('unknown_0xb073b311', _decode_unknown_0xb073b311),
0x719345cf: ('unknown_0x719345cf', _decode_unknown_0x719345cf),
0x5b203cba: ('spike_move_speed', _decode_spike_move_speed),
0x483a338: ('unknown_0x0483a338', _decode_unknown_0x0483a338),
0xe0dcfbbe: ('unknown_struct254', _decode_unknown_struct254),
0x2540a671: ('unknown_struct255', _decode_unknown_struct255),
0xaac2f8da: ('unknown_struct257', _decode_unknown_struct257),
0x17c3e3ec: ('unknown_struct258', _decode_unknown_struct258),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct259.py | 0.600891 | 0.218482 | UnknownStruct259.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerType import PlayerType
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerCommonData(BaseProperty):
player: int = dataclasses.field(default=0)
anim_scale: float = dataclasses.field(default=1.0)
character_type: PlayerType = dataclasses.field(default_factory=PlayerType)
ledge_assist_step_up_height: float = dataclasses.field(default=0.949999988079071)
gravity: float = dataclasses.field(default=55.0)
terminal_velocity: float = dataclasses.field(default=35.0)
invulnerable_time: float = dataclasses.field(default=2.0)
invulnerable_blink_time: float = dataclasses.field(default=0.125)
damage_knock_back_input_disable_time: float = dataclasses.field(default=0.20000000298023224)
respawn_render_push_amount: float = dataclasses.field(default=0.0)
use_terrain_alignment: bool = dataclasses.field(default=True)
allow_collision_with_mine_cart_tracks: bool = dataclasses.field(default=False)
allow_death_delete: bool = dataclasses.field(default=False)
respawn_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
respawn_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x96\xf8\x97\x02') # 0x96f89702
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.player))
data.write(b'\x18x\xfa\x08') # 0x1878fa08
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.anim_scale))
data.write(b'\x01>5\xfb') # 0x13e35fb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2\x1f\xb5\xce') # 0xa21fb5ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ledge_assist_step_up_height))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xab\x95f\xa2') # 0xab9566a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.terminal_velocity))
data.write(b'\xac\x01ZG') # 0xac015a47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.invulnerable_time))
data.write(b'H\xbex\x80') # 0x48be7880
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.invulnerable_blink_time))
data.write(b'\x97Cc{') # 0x9743637b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_knock_back_input_disable_time))
data.write(b'\xb1\x98\xe71') # 0xb198e731
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.respawn_render_push_amount))
data.write(b'a\x17\xe7\x8f') # 0x6117e78f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_terrain_alignment))
data.write(b'\x91{Z\xd5') # 0x917b5ad5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_collision_with_mine_cart_tracks))
data.write(b'{61\x00') # 0x7b363100
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_death_delete))
data.write(b'.P\xdc\xec') # 0x2e50dcec
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.respawn_sound))
data.write(b'Ke\x99\x9c') # 0x4b65999c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.respawn_effect))
@classmethod
def from_json(cls, data: dict):
return cls(
player=data['player'],
anim_scale=data['anim_scale'],
character_type=PlayerType.from_json(data['character_type']),
ledge_assist_step_up_height=data['ledge_assist_step_up_height'],
gravity=data['gravity'],
terminal_velocity=data['terminal_velocity'],
invulnerable_time=data['invulnerable_time'],
invulnerable_blink_time=data['invulnerable_blink_time'],
damage_knock_back_input_disable_time=data['damage_knock_back_input_disable_time'],
respawn_render_push_amount=data['respawn_render_push_amount'],
use_terrain_alignment=data['use_terrain_alignment'],
allow_collision_with_mine_cart_tracks=data['allow_collision_with_mine_cart_tracks'],
allow_death_delete=data['allow_death_delete'],
respawn_sound=data['respawn_sound'],
respawn_effect=data['respawn_effect'],
)
def to_json(self) -> dict:
return {
'player': self.player,
'anim_scale': self.anim_scale,
'character_type': self.character_type.to_json(),
'ledge_assist_step_up_height': self.ledge_assist_step_up_height,
'gravity': self.gravity,
'terminal_velocity': self.terminal_velocity,
'invulnerable_time': self.invulnerable_time,
'invulnerable_blink_time': self.invulnerable_blink_time,
'damage_knock_back_input_disable_time': self.damage_knock_back_input_disable_time,
'respawn_render_push_amount': self.respawn_render_push_amount,
'use_terrain_alignment': self.use_terrain_alignment,
'allow_collision_with_mine_cart_tracks': self.allow_collision_with_mine_cart_tracks,
'allow_death_delete': self.allow_death_delete,
'respawn_sound': self.respawn_sound,
'respawn_effect': self.respawn_effect,
}
def _decode_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_anim_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_character_type(data: typing.BinaryIO, property_size: int):
return PlayerType.from_stream(data, property_size)
def _decode_ledge_assist_step_up_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_terminal_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_invulnerable_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_invulnerable_blink_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_knock_back_input_disable_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_respawn_render_push_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_terrain_alignment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_collision_with_mine_cart_tracks(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_death_delete(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_respawn_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_respawn_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x96f89702: ('player', _decode_player),
0x1878fa08: ('anim_scale', _decode_anim_scale),
0x13e35fb: ('character_type', _decode_character_type),
0xa21fb5ce: ('ledge_assist_step_up_height', _decode_ledge_assist_step_up_height),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xab9566a2: ('terminal_velocity', _decode_terminal_velocity),
0xac015a47: ('invulnerable_time', _decode_invulnerable_time),
0x48be7880: ('invulnerable_blink_time', _decode_invulnerable_blink_time),
0x9743637b: ('damage_knock_back_input_disable_time', _decode_damage_knock_back_input_disable_time),
0xb198e731: ('respawn_render_push_amount', _decode_respawn_render_push_amount),
0x6117e78f: ('use_terrain_alignment', _decode_use_terrain_alignment),
0x917b5ad5: ('allow_collision_with_mine_cart_tracks', _decode_allow_collision_with_mine_cart_tracks),
0x7b363100: ('allow_death_delete', _decode_allow_death_delete),
0x2e50dcec: ('respawn_sound', _decode_respawn_sound),
0x4b65999c: ('respawn_effect', _decode_respawn_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerCommonData.py | 0.563498 | 0.242435 | PlayerCommonData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.Animations import Animations
from retro_data_structures.properties.dkc_returns.archetypes.Groups import Groups
from retro_data_structures.properties.dkc_returns.archetypes.Sets import Sets
@dataclasses.dataclass()
class RetronomeMessage(BaseProperty):
time_offset: float = dataclasses.field(default=0.0)
sets: Sets = dataclasses.field(default_factory=Sets)
groups: Groups = dataclasses.field(default_factory=Groups)
animations: Animations = dataclasses.field(default_factory=Animations)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'%9\xdeF') # 0x2539de46
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_offset))
data.write(b'J\xb7\xd5\xb8') # 0x4ab7d5b8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sets.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe%|\xe1') # 0xfe257ce1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.groups.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd7\x8aK\x1f') # 0xd78a4b1f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animations.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
time_offset=data['time_offset'],
sets=Sets.from_json(data['sets']),
groups=Groups.from_json(data['groups']),
animations=Animations.from_json(data['animations']),
)
def to_json(self) -> dict:
return {
'time_offset': self.time_offset,
'sets': self.sets.to_json(),
'groups': self.groups.to_json(),
'animations': self.animations.to_json(),
}
def _decode_time_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sets(data: typing.BinaryIO, property_size: int):
return Sets.from_stream(data, property_size)
def _decode_groups(data: typing.BinaryIO, property_size: int):
return Groups.from_stream(data, property_size)
def _decode_animations(data: typing.BinaryIO, property_size: int):
return Animations.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2539de46: ('time_offset', _decode_time_offset),
0x4ab7d5b8: ('sets', _decode_sets),
0xfe257ce1: ('groups', _decode_groups),
0xd78a4b1f: ('animations', _decode_animations),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RetronomeMessage.py | 0.63443 | 0.307137 | RetronomeMessage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class OceanBridgeStructA(BaseProperty):
model_select: enums.ModelSelect = dataclasses.field(default=enums.ModelSelect.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'W0\x049') # 0x57300439
data.write(b'\x00\x04') # size
self.model_select.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
model_select=enums.ModelSelect.from_json(data['model_select']),
)
def to_json(self) -> dict:
return {
'model_select': self.model_select.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x57300439)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OceanBridgeStructA]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return OceanBridgeStructA(
enums.ModelSelect(dec[2]),
)
def _decode_model_select(data: typing.BinaryIO, property_size: int):
return enums.ModelSelect.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x57300439: ('model_select', _decode_model_select),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OceanBridgeStructA.py | 0.626467 | 0.273432 | OceanBridgeStructA.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.BehaviorData import BehaviorData
@dataclasses.dataclass()
class BehaviorsData(BaseProperty):
behavior0: BehaviorData = dataclasses.field(default_factory=BehaviorData)
behavior1: BehaviorData = dataclasses.field(default_factory=BehaviorData)
behavior2: BehaviorData = dataclasses.field(default_factory=BehaviorData)
behavior3: BehaviorData = dataclasses.field(default_factory=BehaviorData)
behavior4: BehaviorData = dataclasses.field(default_factory=BehaviorData)
behavior5: BehaviorData = dataclasses.field(default_factory=BehaviorData)
behavior6: BehaviorData = dataclasses.field(default_factory=BehaviorData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xabG\x97_') # 0xab47975f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior0.to_stream(data, default_override={'behavior_type': enums.BehaviorType.Unknown2})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\xd1N\xda') # 0x76d14eda
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior1.to_stream(data, default_override={'behavior_type': enums.BehaviorType.Unknown7})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\x1b"\x14') # 0xcb1b2214
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior2.to_stream(data, default_override={'behavior_type': enums.BehaviorType.Unknown3})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\x8d\xfb\x91') # 0x168dfb91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior3.to_stream(data, default_override={'behavior_type': enums.BehaviorType.Unknown4})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k\xfe\xfd\xc9') # 0x6bfefdc9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior4.to_stream(data, default_override={'behavior_type': enums.BehaviorType.Unknown5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6h$L') # 0xb668244c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0b\xa2H\x82') # 0xba24882
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
behavior0=BehaviorData.from_json(data['behavior0']),
behavior1=BehaviorData.from_json(data['behavior1']),
behavior2=BehaviorData.from_json(data['behavior2']),
behavior3=BehaviorData.from_json(data['behavior3']),
behavior4=BehaviorData.from_json(data['behavior4']),
behavior5=BehaviorData.from_json(data['behavior5']),
behavior6=BehaviorData.from_json(data['behavior6']),
)
def to_json(self) -> dict:
return {
'behavior0': self.behavior0.to_json(),
'behavior1': self.behavior1.to_json(),
'behavior2': self.behavior2.to_json(),
'behavior3': self.behavior3.to_json(),
'behavior4': self.behavior4.to_json(),
'behavior5': self.behavior5.to_json(),
'behavior6': self.behavior6.to_json(),
}
def _decode_behavior0(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size, default_override={'behavior_type': enums.BehaviorType.Unknown2})
def _decode_behavior1(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size, default_override={'behavior_type': enums.BehaviorType.Unknown7})
def _decode_behavior2(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size, default_override={'behavior_type': enums.BehaviorType.Unknown3})
def _decode_behavior3(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size, default_override={'behavior_type': enums.BehaviorType.Unknown4})
def _decode_behavior4(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size, default_override={'behavior_type': enums.BehaviorType.Unknown5})
def _decode_behavior5(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size)
def _decode_behavior6(data: typing.BinaryIO, property_size: int):
return BehaviorData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xab47975f: ('behavior0', _decode_behavior0),
0x76d14eda: ('behavior1', _decode_behavior1),
0xcb1b2214: ('behavior2', _decode_behavior2),
0x168dfb91: ('behavior3', _decode_behavior3),
0x6bfefdc9: ('behavior4', _decode_behavior4),
0xb668244c: ('behavior5', _decode_behavior5),
0xba24882: ('behavior6', _decode_behavior6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BehaviorsData.py | 0.599251 | 0.318763 | BehaviorsData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct57 import UnknownStruct57
@dataclasses.dataclass()
class UnknownStruct286(BaseProperty):
size: int = dataclasses.field(default=0)
unknown_struct57_0xa8233351: UnknownStruct57 = dataclasses.field(default_factory=UnknownStruct57)
unknown_struct57_0xf3348244: UnknownStruct57 = dataclasses.field(default_factory=UnknownStruct57)
unknown_struct57_0xc5c612b7: UnknownStruct57 = dataclasses.field(default_factory=UnknownStruct57)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x0b\xdfq\xc5') # 0xbdf71c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.size))
data.write(b'\xa8#3Q') # 0xa8233351
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct57_0xa8233351.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf34\x82D') # 0xf3348244
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct57_0xf3348244.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5\xc6\x12\xb7') # 0xc5c612b7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct57_0xc5c612b7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
size=data['size'],
unknown_struct57_0xa8233351=UnknownStruct57.from_json(data['unknown_struct57_0xa8233351']),
unknown_struct57_0xf3348244=UnknownStruct57.from_json(data['unknown_struct57_0xf3348244']),
unknown_struct57_0xc5c612b7=UnknownStruct57.from_json(data['unknown_struct57_0xc5c612b7']),
)
def to_json(self) -> dict:
return {
'size': self.size,
'unknown_struct57_0xa8233351': self.unknown_struct57_0xa8233351.to_json(),
'unknown_struct57_0xf3348244': self.unknown_struct57_0xf3348244.to_json(),
'unknown_struct57_0xc5c612b7': self.unknown_struct57_0xc5c612b7.to_json(),
}
def _decode_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct57_0xa8233351(data: typing.BinaryIO, property_size: int):
return UnknownStruct57.from_stream(data, property_size)
def _decode_unknown_struct57_0xf3348244(data: typing.BinaryIO, property_size: int):
return UnknownStruct57.from_stream(data, property_size)
def _decode_unknown_struct57_0xc5c612b7(data: typing.BinaryIO, property_size: int):
return UnknownStruct57.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbdf71c5: ('size', _decode_size),
0xa8233351: ('unknown_struct57_0xa8233351', _decode_unknown_struct57_0xa8233351),
0xf3348244: ('unknown_struct57_0xf3348244', _decode_unknown_struct57_0xf3348244),
0xc5c612b7: ('unknown_struct57_0xc5c612b7', _decode_unknown_struct57_0xc5c612b7),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct286.py | 0.583441 | 0.273744 | UnknownStruct286.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct33(BaseProperty):
rotates_about: enums.RotatesAbout = dataclasses.field(default=enums.RotatesAbout.Unknown2)
start_orientation: enums.StartOrientation = dataclasses.field(default=enums.StartOrientation.Unknown1)
idle_orientation: enums.IdleOrientation = dataclasses.field(default=enums.IdleOrientation.Unknown1)
rotational_acceleration: float = dataclasses.field(default=0.0)
max_rotational_velocity: float = dataclasses.field(default=0.0)
maximum_tilt: float = dataclasses.field(default=0.0)
maximum_tilt_right_threshold: float = dataclasses.field(default=5.0)
maximum_tilt_left_threshold: float = dataclasses.field(default=5.0)
balanced_threshold: float = dataclasses.field(default=5.0)
begin_tilt_damp_angle_threshold: float = dataclasses.field(default=0.0)
tilt_velocity_percentage: Spline = dataclasses.field(default_factory=Spline)
begin_balanced_damp_angle_threshold: float = dataclasses.field(default=0.0)
balanced_velocity_percentage: Spline = dataclasses.field(default_factory=Spline)
rotate_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rotate_stop_balanced_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rotate_stop_tilted_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rotate_sound_ratio_change_factor: float = dataclasses.field(default=0.5)
rotate_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
rotate_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
rotate_sound_volume: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x14') # 20 properties
data.write(b'/\x82y\x82') # 0x2f827982
data.write(b'\x00\x04') # size
self.rotates_about.to_stream(data)
data.write(b't\xce\xcb\xeb') # 0x74cecbeb
data.write(b'\x00\x04') # size
self.start_orientation.to_stream(data)
data.write(b'#\xa9\xad\xd2') # 0x23a9add2
data.write(b'\x00\x04') # size
self.idle_orientation.to_stream(data)
data.write(b'H\xe5\x82\x14') # 0x48e58214
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotational_acceleration))
data.write(b']\xe3%\xe7') # 0x5de325e7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_rotational_velocity))
data.write(b'\xb1L\x94t') # 0xb14c9474
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_tilt))
data.write(b'/\x1b\xeb\xad') # 0x2f1bebad
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_tilt_right_threshold))
data.write(b'\x7f\x85+\xb9') # 0x7f852bb9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_tilt_left_threshold))
data.write(b'\xfa\xfb;\xfe') # 0xfafb3bfe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.balanced_threshold))
data.write(b'\xbe\x0f[\xab') # 0xbe0f5bab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.begin_tilt_damp_angle_threshold))
data.write(b'\xae\xa7\r\xd9') # 0xaea70dd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tilt_velocity_percentage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8a\xbc%\xf2') # 0x8abc25f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.begin_balanced_damp_angle_threshold))
data.write(b'Y)\x9ee') # 0x59299e65
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balanced_velocity_percentage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd5J[\xd8') # 0xd54a5bd8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rotate_sound))
data.write(b'KH\x18\xee') # 0x4b4818ee
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rotate_stop_balanced_sound))
data.write(b'J\x9bB\x99') # 0x4a9b4299
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rotate_stop_tilted_sound))
data.write(b'., -') # 0x2e2c202d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotate_sound_ratio_change_factor))
data.write(b'\x15\xcc%\xfd') # 0x15cc25fd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotate_sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91i\xccY') # 0x9169cc59
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotate_sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'}\xda\x10\xce') # 0x7dda10ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotate_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
rotates_about=enums.RotatesAbout.from_json(data['rotates_about']),
start_orientation=enums.StartOrientation.from_json(data['start_orientation']),
idle_orientation=enums.IdleOrientation.from_json(data['idle_orientation']),
rotational_acceleration=data['rotational_acceleration'],
max_rotational_velocity=data['max_rotational_velocity'],
maximum_tilt=data['maximum_tilt'],
maximum_tilt_right_threshold=data['maximum_tilt_right_threshold'],
maximum_tilt_left_threshold=data['maximum_tilt_left_threshold'],
balanced_threshold=data['balanced_threshold'],
begin_tilt_damp_angle_threshold=data['begin_tilt_damp_angle_threshold'],
tilt_velocity_percentage=Spline.from_json(data['tilt_velocity_percentage']),
begin_balanced_damp_angle_threshold=data['begin_balanced_damp_angle_threshold'],
balanced_velocity_percentage=Spline.from_json(data['balanced_velocity_percentage']),
rotate_sound=data['rotate_sound'],
rotate_stop_balanced_sound=data['rotate_stop_balanced_sound'],
rotate_stop_tilted_sound=data['rotate_stop_tilted_sound'],
rotate_sound_ratio_change_factor=data['rotate_sound_ratio_change_factor'],
rotate_sound_low_pass_filter=Spline.from_json(data['rotate_sound_low_pass_filter']),
rotate_sound_pitch=Spline.from_json(data['rotate_sound_pitch']),
rotate_sound_volume=Spline.from_json(data['rotate_sound_volume']),
)
def to_json(self) -> dict:
return {
'rotates_about': self.rotates_about.to_json(),
'start_orientation': self.start_orientation.to_json(),
'idle_orientation': self.idle_orientation.to_json(),
'rotational_acceleration': self.rotational_acceleration,
'max_rotational_velocity': self.max_rotational_velocity,
'maximum_tilt': self.maximum_tilt,
'maximum_tilt_right_threshold': self.maximum_tilt_right_threshold,
'maximum_tilt_left_threshold': self.maximum_tilt_left_threshold,
'balanced_threshold': self.balanced_threshold,
'begin_tilt_damp_angle_threshold': self.begin_tilt_damp_angle_threshold,
'tilt_velocity_percentage': self.tilt_velocity_percentage.to_json(),
'begin_balanced_damp_angle_threshold': self.begin_balanced_damp_angle_threshold,
'balanced_velocity_percentage': self.balanced_velocity_percentage.to_json(),
'rotate_sound': self.rotate_sound,
'rotate_stop_balanced_sound': self.rotate_stop_balanced_sound,
'rotate_stop_tilted_sound': self.rotate_stop_tilted_sound,
'rotate_sound_ratio_change_factor': self.rotate_sound_ratio_change_factor,
'rotate_sound_low_pass_filter': self.rotate_sound_low_pass_filter.to_json(),
'rotate_sound_pitch': self.rotate_sound_pitch.to_json(),
'rotate_sound_volume': self.rotate_sound_volume.to_json(),
}
def _decode_rotates_about(data: typing.BinaryIO, property_size: int):
return enums.RotatesAbout.from_stream(data)
def _decode_start_orientation(data: typing.BinaryIO, property_size: int):
return enums.StartOrientation.from_stream(data)
def _decode_idle_orientation(data: typing.BinaryIO, property_size: int):
return enums.IdleOrientation.from_stream(data)
def _decode_rotational_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_rotational_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_tilt(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_tilt_right_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_tilt_left_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_balanced_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_begin_tilt_damp_angle_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tilt_velocity_percentage(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_begin_balanced_damp_angle_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_balanced_velocity_percentage(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rotate_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rotate_stop_balanced_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rotate_stop_tilted_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rotate_sound_ratio_change_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotate_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rotate_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rotate_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f827982: ('rotates_about', _decode_rotates_about),
0x74cecbeb: ('start_orientation', _decode_start_orientation),
0x23a9add2: ('idle_orientation', _decode_idle_orientation),
0x48e58214: ('rotational_acceleration', _decode_rotational_acceleration),
0x5de325e7: ('max_rotational_velocity', _decode_max_rotational_velocity),
0xb14c9474: ('maximum_tilt', _decode_maximum_tilt),
0x2f1bebad: ('maximum_tilt_right_threshold', _decode_maximum_tilt_right_threshold),
0x7f852bb9: ('maximum_tilt_left_threshold', _decode_maximum_tilt_left_threshold),
0xfafb3bfe: ('balanced_threshold', _decode_balanced_threshold),
0xbe0f5bab: ('begin_tilt_damp_angle_threshold', _decode_begin_tilt_damp_angle_threshold),
0xaea70dd9: ('tilt_velocity_percentage', _decode_tilt_velocity_percentage),
0x8abc25f2: ('begin_balanced_damp_angle_threshold', _decode_begin_balanced_damp_angle_threshold),
0x59299e65: ('balanced_velocity_percentage', _decode_balanced_velocity_percentage),
0xd54a5bd8: ('rotate_sound', _decode_rotate_sound),
0x4b4818ee: ('rotate_stop_balanced_sound', _decode_rotate_stop_balanced_sound),
0x4a9b4299: ('rotate_stop_tilted_sound', _decode_rotate_stop_tilted_sound),
0x2e2c202d: ('rotate_sound_ratio_change_factor', _decode_rotate_sound_ratio_change_factor),
0x15cc25fd: ('rotate_sound_low_pass_filter', _decode_rotate_sound_low_pass_filter),
0x9169cc59: ('rotate_sound_pitch', _decode_rotate_sound_pitch),
0x7dda10ce: ('rotate_sound_volume', _decode_rotate_sound_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct33.py | 0.657098 | 0.240886 | UnknownStruct33.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMultiKillRewardSoundData import PlayerMultiKillRewardSoundData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMultiKillRewardTierData import PlayerMultiKillRewardTierData
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class PlayerMultiKillRewardData(BaseProperty):
reveal_height_spline: Spline = dataclasses.field(default_factory=Spline)
tier1: PlayerMultiKillRewardTierData = dataclasses.field(default_factory=PlayerMultiKillRewardTierData)
tier2: PlayerMultiKillRewardTierData = dataclasses.field(default_factory=PlayerMultiKillRewardTierData)
sound: PlayerMultiKillRewardSoundData = dataclasses.field(default_factory=PlayerMultiKillRewardSoundData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'2\x15*\xb2') # 0x32152ab2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.reveal_height_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00^;\xe9') # 0x5e3be9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tier1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D\xff\x1e\xf1') # 0x44ff1ef1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tier2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\x84\xae\xa3') # 0x7384aea3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
reveal_height_spline=Spline.from_json(data['reveal_height_spline']),
tier1=PlayerMultiKillRewardTierData.from_json(data['tier1']),
tier2=PlayerMultiKillRewardTierData.from_json(data['tier2']),
sound=PlayerMultiKillRewardSoundData.from_json(data['sound']),
)
def to_json(self) -> dict:
return {
'reveal_height_spline': self.reveal_height_spline.to_json(),
'tier1': self.tier1.to_json(),
'tier2': self.tier2.to_json(),
'sound': self.sound.to_json(),
}
def _decode_reveal_height_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_tier1(data: typing.BinaryIO, property_size: int):
return PlayerMultiKillRewardTierData.from_stream(data, property_size)
def _decode_tier2(data: typing.BinaryIO, property_size: int):
return PlayerMultiKillRewardTierData.from_stream(data, property_size)
def _decode_sound(data: typing.BinaryIO, property_size: int):
return PlayerMultiKillRewardSoundData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x32152ab2: ('reveal_height_spline', _decode_reveal_height_spline),
0x5e3be9: ('tier1', _decode_tier1),
0x44ff1ef1: ('tier2', _decode_tier2),
0x7384aea3: ('sound', _decode_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMultiKillRewardData.py | 0.619817 | 0.273759 | PlayerMultiKillRewardData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class PlayerAttachment(BaseProperty):
attachment_model: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
attachment_locator: str = dataclasses.field(default='')
unknown: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'R\x0e\xbbh') # 0x520ebb68
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attachment_model.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe8V\xfc+') # 0xe856fc2b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.attachment_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'&b\x92\x9f') # 0x2662929f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
attachment_model=AnimationParameters.from_json(data['attachment_model']),
attachment_locator=data['attachment_locator'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'attachment_model': self.attachment_model.to_json(),
'attachment_locator': self.attachment_locator,
'unknown': self.unknown,
}
def _decode_attachment_model(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_attachment_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x520ebb68: ('attachment_model', _decode_attachment_model),
0xe856fc2b: ('attachment_locator', _decode_attachment_locator),
0x2662929f: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerAttachment.py | 0.638835 | 0.336944 | PlayerAttachment.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.ReactiveActorBehavior import ReactiveActorBehavior
@dataclasses.dataclass()
class ReactiveActorBehaviors(BaseProperty):
num_behaviors: int = dataclasses.field(default=0)
behavior1: ReactiveActorBehavior = dataclasses.field(default_factory=ReactiveActorBehavior)
behavior2: ReactiveActorBehavior = dataclasses.field(default_factory=ReactiveActorBehavior)
behavior3: ReactiveActorBehavior = dataclasses.field(default_factory=ReactiveActorBehavior)
behavior4: ReactiveActorBehavior = dataclasses.field(default_factory=ReactiveActorBehavior)
behavior5: ReactiveActorBehavior = dataclasses.field(default_factory=ReactiveActorBehavior)
behavior6: ReactiveActorBehavior = dataclasses.field(default_factory=ReactiveActorBehavior)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xc0\x7f\xa9\xbe') # 0xc07fa9be
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_behaviors))
data.write(b'\x8e\xa6|O') # 0x8ea67c4f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb7\xde\xd1\x0f') # 0xb7ded10f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa0\xf6\xb5\xcf') # 0xa0f6b5cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5/\x8b\x8f') # 0xc52f8b8f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd2\x07\xefO') # 0xd207ef4f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\x7fB\x0f') # 0xeb7f420f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behavior6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
num_behaviors=data['num_behaviors'],
behavior1=ReactiveActorBehavior.from_json(data['behavior1']),
behavior2=ReactiveActorBehavior.from_json(data['behavior2']),
behavior3=ReactiveActorBehavior.from_json(data['behavior3']),
behavior4=ReactiveActorBehavior.from_json(data['behavior4']),
behavior5=ReactiveActorBehavior.from_json(data['behavior5']),
behavior6=ReactiveActorBehavior.from_json(data['behavior6']),
)
def to_json(self) -> dict:
return {
'num_behaviors': self.num_behaviors,
'behavior1': self.behavior1.to_json(),
'behavior2': self.behavior2.to_json(),
'behavior3': self.behavior3.to_json(),
'behavior4': self.behavior4.to_json(),
'behavior5': self.behavior5.to_json(),
'behavior6': self.behavior6.to_json(),
}
def _decode_num_behaviors(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_behavior1(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehavior.from_stream(data, property_size)
def _decode_behavior2(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehavior.from_stream(data, property_size)
def _decode_behavior3(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehavior.from_stream(data, property_size)
def _decode_behavior4(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehavior.from_stream(data, property_size)
def _decode_behavior5(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehavior.from_stream(data, property_size)
def _decode_behavior6(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehavior.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc07fa9be: ('num_behaviors', _decode_num_behaviors),
0x8ea67c4f: ('behavior1', _decode_behavior1),
0xb7ded10f: ('behavior2', _decode_behavior2),
0xa0f6b5cf: ('behavior3', _decode_behavior3),
0xc52f8b8f: ('behavior4', _decode_behavior4),
0xd207ef4f: ('behavior5', _decode_behavior5),
0xeb7f420f: ('behavior6', _decode_behavior6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ReactiveActorBehaviors.py | 0.600891 | 0.249905 | ReactiveActorBehaviors.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class UnknownStruct241(BaseProperty):
part_of_music_system: bool = dataclasses.field(default=False)
auto_buffer: bool = dataclasses.field(default=False)
auto_buffer_when_stopped: bool = dataclasses.field(default=False)
auto_play_when_buffered: bool = dataclasses.field(default=False)
fade_in_time: float = dataclasses.field(default=0.05000000074505806)
fade_out_time: float = dataclasses.field(default=0.25)
volume: float = dataclasses.field(default=-6.0)
save_preload_data: bool = dataclasses.field(default=False)
start_delay: float = dataclasses.field(default=0.0)
music_system_area_state: enums.MusicEnumB = dataclasses.field(default=enums.MusicEnumB.Unknown1)
volume_type: enums.MusicEnumA = dataclasses.field(default=enums.MusicEnumA.Unknown2)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'.|t_') # 0x2e7c745f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.part_of_music_system))
data.write(b'\xc0>\xc2q') # 0xc03ec271
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_buffer))
data.write(b'\x0ehu\x18') # 0xe687518
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_buffer_when_stopped))
data.write(b'\xea\x8dT\xf4') # 0xea8d54f4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_play_when_buffered))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'\xd7BE\xa4') # 0xd74245a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.save_preload_data))
data.write(b'\x19n\x17\xd9') # 0x196e17d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_delay))
data.write(b'\xfb\x8f\x0b\x1f') # 0xfb8f0b1f
data.write(b'\x00\x04') # size
self.music_system_area_state.to_stream(data)
data.write(b'\x95Xq\x1e') # 0x9558711e
data.write(b'\x00\x04') # size
self.volume_type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
part_of_music_system=data['part_of_music_system'],
auto_buffer=data['auto_buffer'],
auto_buffer_when_stopped=data['auto_buffer_when_stopped'],
auto_play_when_buffered=data['auto_play_when_buffered'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
volume=data['volume'],
save_preload_data=data['save_preload_data'],
start_delay=data['start_delay'],
music_system_area_state=enums.MusicEnumB.from_json(data['music_system_area_state']),
volume_type=enums.MusicEnumA.from_json(data['volume_type']),
)
def to_json(self) -> dict:
return {
'part_of_music_system': self.part_of_music_system,
'auto_buffer': self.auto_buffer,
'auto_buffer_when_stopped': self.auto_buffer_when_stopped,
'auto_play_when_buffered': self.auto_play_when_buffered,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'volume': self.volume,
'save_preload_data': self.save_preload_data,
'start_delay': self.start_delay,
'music_system_area_state': self.music_system_area_state.to_json(),
'volume_type': self.volume_type.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x2e7c745f, 0xc03ec271, 0xe687518, 0xea8d54f4, 0x90aa341f, 0x7c269ebc, 0xc7a7f189, 0xd74245a4, 0x196e17d9, 0xfb8f0b1f, 0x9558711e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct241]:
if property_count != 11:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LHfLHfLHfLH?LHfLHLLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(95))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct241(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
enums.MusicEnumB(dec[29]),
enums.MusicEnumA(dec[32]),
)
def _decode_part_of_music_system(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_buffer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_buffer_when_stopped(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_play_when_buffered(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_save_preload_data(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_music_system_area_state(data: typing.BinaryIO, property_size: int):
return enums.MusicEnumB.from_stream(data)
def _decode_volume_type(data: typing.BinaryIO, property_size: int):
return enums.MusicEnumA.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2e7c745f: ('part_of_music_system', _decode_part_of_music_system),
0xc03ec271: ('auto_buffer', _decode_auto_buffer),
0xe687518: ('auto_buffer_when_stopped', _decode_auto_buffer_when_stopped),
0xea8d54f4: ('auto_play_when_buffered', _decode_auto_play_when_buffered),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0xc7a7f189: ('volume', _decode_volume),
0xd74245a4: ('save_preload_data', _decode_save_preload_data),
0x196e17d9: ('start_delay', _decode_start_delay),
0xfb8f0b1f: ('music_system_area_state', _decode_music_system_area_state),
0x9558711e: ('volume_type', _decode_volume_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct241.py | 0.588061 | 0.261959 | UnknownStruct241.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class RotationSplines(BaseProperty):
x_rotation: Spline = dataclasses.field(default_factory=Spline)
y_rotation: Spline = dataclasses.field(default_factory=Spline)
z_rotation: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'i\xd8D}') # 0x69d8447d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd0#\x9f\x95') # 0xd0239f95
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc1^\xf5\xec') # 0xc15ef5ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_rotation=Spline.from_json(data['x_rotation']),
y_rotation=Spline.from_json(data['y_rotation']),
z_rotation=Spline.from_json(data['z_rotation']),
)
def to_json(self) -> dict:
return {
'x_rotation': self.x_rotation.to_json(),
'y_rotation': self.y_rotation.to_json(),
'z_rotation': self.z_rotation.to_json(),
}
def _decode_x_rotation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_rotation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_rotation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x69d8447d: ('x_rotation', _decode_x_rotation),
0xd0239f95: ('y_rotation', _decode_y_rotation),
0xc15ef5ec: ('z_rotation', _decode_z_rotation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RotationSplines.py | 0.706899 | 0.339609 | RotationSplines.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.AreaPathStructA import AreaPathStructA
@dataclasses.dataclass()
class NonSlowdown(BaseProperty):
path_shape: AreaPathStructA = dataclasses.field(default_factory=AreaPathStructA)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x7f\xcdi\x08') # 0x7fcd6908
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_shape.to_stream(data, default_override={'curvature': enums.Curvature.Unknown4})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
path_shape=AreaPathStructA.from_json(data['path_shape']),
)
def to_json(self) -> dict:
return {
'path_shape': self.path_shape.to_json(),
}
def _decode_path_shape(data: typing.BinaryIO, property_size: int):
return AreaPathStructA.from_stream(data, property_size, default_override={'curvature': enums.Curvature.Unknown4})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7fcd6908: ('path_shape', _decode_path_shape),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/NonSlowdown.py | 0.608943 | 0.276166 | NonSlowdown.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerAttachment import PlayerAttachment
@dataclasses.dataclass()
class PlayerAttachmentsData(BaseProperty):
player_attachment01: PlayerAttachment = dataclasses.field(default_factory=PlayerAttachment)
player_attachment02: PlayerAttachment = dataclasses.field(default_factory=PlayerAttachment)
player_attachment03: PlayerAttachment = dataclasses.field(default_factory=PlayerAttachment)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'M/\xf4k') # 0x4d2ff46b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_attachment01.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1e\xb5\xaf\xef') # 0x1eb5afef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_attachment02.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x99\x13d\xac') # 0x991364ac
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_attachment03.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
player_attachment01=PlayerAttachment.from_json(data['player_attachment01']),
player_attachment02=PlayerAttachment.from_json(data['player_attachment02']),
player_attachment03=PlayerAttachment.from_json(data['player_attachment03']),
)
def to_json(self) -> dict:
return {
'player_attachment01': self.player_attachment01.to_json(),
'player_attachment02': self.player_attachment02.to_json(),
'player_attachment03': self.player_attachment03.to_json(),
}
def _decode_player_attachment01(data: typing.BinaryIO, property_size: int):
return PlayerAttachment.from_stream(data, property_size)
def _decode_player_attachment02(data: typing.BinaryIO, property_size: int):
return PlayerAttachment.from_stream(data, property_size)
def _decode_player_attachment03(data: typing.BinaryIO, property_size: int):
return PlayerAttachment.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4d2ff46b: ('player_attachment01', _decode_player_attachment01),
0x1eb5afef: ('player_attachment02', _decode_player_attachment02),
0x991364ac: ('player_attachment03', _decode_player_attachment03),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerAttachmentsData.py | 0.622574 | 0.373276 | PlayerAttachmentsData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class PlayerMultiKillRewardTierData(BaseProperty):
item_to_give: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.Banana)
bop_threshold: int = dataclasses.field(default=1)
throw_kill_threshold: int = dataclasses.field(default=1)
barrel_cannon_kill_threshold: int = dataclasses.field(default=1)
reward_speed: float = dataclasses.field(default=1.0)
reward_target_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
reward_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
reward_reveal_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
reward_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\xa0.\xf0\xc4') # 0xa02ef0c4
data.write(b'\x00\x04') # size
self.item_to_give.to_stream(data)
data.write(b'{|&*') # 0x7b7c262a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.bop_threshold))
data.write(b'\xdb(\x9bU') # 0xdb289b55
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.throw_kill_threshold))
data.write(b'\xa7~\xfc\x04') # 0xa77efc04
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.barrel_cannon_kill_threshold))
data.write(b'&X\x95\x8d') # 0x2658958d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reward_speed))
data.write(b'8K\xaf6') # 0x384baf36
data.write(b'\x00\x0c') # size
self.reward_target_scale.to_stream(data)
data.write(b'\x87\xb5/L') # 0x87b52f4c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.reward_model))
data.write(b'\xab[\x8c\xaf') # 0xab5b8caf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.reward_reveal_effect))
data.write(b'\xb4\xa44I') # 0xb4a43449
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.reward_effect))
@classmethod
def from_json(cls, data: dict):
return cls(
item_to_give=enums.PlayerItem.from_json(data['item_to_give']),
bop_threshold=data['bop_threshold'],
throw_kill_threshold=data['throw_kill_threshold'],
barrel_cannon_kill_threshold=data['barrel_cannon_kill_threshold'],
reward_speed=data['reward_speed'],
reward_target_scale=Vector.from_json(data['reward_target_scale']),
reward_model=data['reward_model'],
reward_reveal_effect=data['reward_reveal_effect'],
reward_effect=data['reward_effect'],
)
def to_json(self) -> dict:
return {
'item_to_give': self.item_to_give.to_json(),
'bop_threshold': self.bop_threshold,
'throw_kill_threshold': self.throw_kill_threshold,
'barrel_cannon_kill_threshold': self.barrel_cannon_kill_threshold,
'reward_speed': self.reward_speed,
'reward_target_scale': self.reward_target_scale.to_json(),
'reward_model': self.reward_model,
'reward_reveal_effect': self.reward_reveal_effect,
'reward_effect': self.reward_effect,
}
def _decode_item_to_give(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_bop_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_throw_kill_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_barrel_cannon_kill_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_reward_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reward_target_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_reward_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_reward_reveal_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_reward_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa02ef0c4: ('item_to_give', _decode_item_to_give),
0x7b7c262a: ('bop_threshold', _decode_bop_threshold),
0xdb289b55: ('throw_kill_threshold', _decode_throw_kill_threshold),
0xa77efc04: ('barrel_cannon_kill_threshold', _decode_barrel_cannon_kill_threshold),
0x2658958d: ('reward_speed', _decode_reward_speed),
0x384baf36: ('reward_target_scale', _decode_reward_target_scale),
0x87b52f4c: ('reward_model', _decode_reward_model),
0xab5b8caf: ('reward_reveal_effect', _decode_reward_reveal_effect),
0xb4a43449: ('reward_effect', _decode_reward_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMultiKillRewardTierData.py | 0.675015 | 0.253821 | PlayerMultiKillRewardTierData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerCrouchData(BaseProperty):
push_down_threshold: float = dataclasses.field(default=0.800000011920929)
angle_threshold: float = dataclasses.field(default=30.0)
deceleration: float = dataclasses.field(default=9.0)
backflip_spin_jump_height: float = dataclasses.field(default=6.5)
blow_message_interval: float = dataclasses.field(default=0.25)
blow_forward_range: float = dataclasses.field(default=3.0)
blow_vertical_range: float = dataclasses.field(default=1.125)
min_blow_time: float = dataclasses.field(default=0.20000000298023224)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\xba\x08\x9b\xb4') # 0xba089bb4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.push_down_threshold))
data.write(b']\t\x0b\x9a') # 0x5d090b9a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angle_threshold))
data.write(b'\x9e\xc4\xfc\x10') # 0x9ec4fc10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deceleration))
data.write(b'\xc6A\xa9k') # 0xc641a96b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.backflip_spin_jump_height))
data.write(b'\x94!\xe3F') # 0x9421e346
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.blow_message_interval))
data.write(b'\xef6\xae2') # 0xef36ae32
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.blow_forward_range))
data.write(b'\x1d\xc2\xbfG') # 0x1dc2bf47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.blow_vertical_range))
data.write(b'=\x8f\xc0\xf4') # 0x3d8fc0f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_blow_time))
@classmethod
def from_json(cls, data: dict):
return cls(
push_down_threshold=data['push_down_threshold'],
angle_threshold=data['angle_threshold'],
deceleration=data['deceleration'],
backflip_spin_jump_height=data['backflip_spin_jump_height'],
blow_message_interval=data['blow_message_interval'],
blow_forward_range=data['blow_forward_range'],
blow_vertical_range=data['blow_vertical_range'],
min_blow_time=data['min_blow_time'],
)
def to_json(self) -> dict:
return {
'push_down_threshold': self.push_down_threshold,
'angle_threshold': self.angle_threshold,
'deceleration': self.deceleration,
'backflip_spin_jump_height': self.backflip_spin_jump_height,
'blow_message_interval': self.blow_message_interval,
'blow_forward_range': self.blow_forward_range,
'blow_vertical_range': self.blow_vertical_range,
'min_blow_time': self.min_blow_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0xba089bb4, 0x5d090b9a, 0x9ec4fc10, 0xc641a96b, 0x9421e346, 0xef36ae32, 0x1dc2bf47, 0x3d8fc0f4)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerCrouchData]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(80))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21]) != _FAST_IDS:
data.seek(before)
return None
return PlayerCrouchData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_push_down_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_angle_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_backflip_spin_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_blow_message_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_blow_forward_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_blow_vertical_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_blow_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xba089bb4: ('push_down_threshold', _decode_push_down_threshold),
0x5d090b9a: ('angle_threshold', _decode_angle_threshold),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0xc641a96b: ('backflip_spin_jump_height', _decode_backflip_spin_jump_height),
0x9421e346: ('blow_message_interval', _decode_blow_message_interval),
0xef36ae32: ('blow_forward_range', _decode_blow_forward_range),
0x1dc2bf47: ('blow_vertical_range', _decode_blow_vertical_range),
0x3d8fc0f4: ('min_blow_time', _decode_min_blow_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerCrouchData.py | 0.637257 | 0.32985 | PlayerCrouchData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.BopJumpData import BopJumpData
@dataclasses.dataclass()
class BopJumpBehaviorData(BaseProperty):
bop_jump_type: enums.BopJumpType = dataclasses.field(default=enums.BopJumpType.Unknown1)
number_of_jumps: int = dataclasses.field(default=2)
jump1: BopJumpData = dataclasses.field(default_factory=BopJumpData)
jump2: BopJumpData = dataclasses.field(default_factory=BopJumpData)
jump3: BopJumpData = dataclasses.field(default_factory=BopJumpData)
jump4: BopJumpData = dataclasses.field(default_factory=BopJumpData)
jump5: BopJumpData = dataclasses.field(default_factory=BopJumpData)
jump_delay_time: float = dataclasses.field(default=1.0)
no_actor_collision: bool = dataclasses.field(default=False)
turn_at_bounds: bool = dataclasses.field(default=True)
direction_control: enums.DirectionControl = dataclasses.field(default=enums.DirectionControl.Unknown1)
jump_when_player_jumps: bool = dataclasses.field(default=False)
jump_when_bumping_wall: bool = dataclasses.field(default=False)
ignore_tar_inhibited_players: bool = dataclasses.field(default=True)
minimum_seek_direction_time: float = dataclasses.field(default=3.0)
pursuit_distance: float = dataclasses.field(default=0.0)
reverse_base_chance: float = dataclasses.field(default=10.0)
reverse_additional_chance: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x12') # 18 properties
data.write(b'v\xe1p\xef') # 0x76e170ef
data.write(b'\x00\x04') # size
self.bop_jump_type.to_stream(data)
data.write(b'\xf2\xb3\xc5\xa1') # 0xf2b3c5a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_jumps))
data.write(b'\xcbV\x07c') # 0xcb560763
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\xc8\xd5\x93') # 0xbcc8d593
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump2.to_stream(data, default_override={'height': 2.0, 'distance': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'m\x99\xfc") # 0x276d99fc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S\xf5ps') # 0x53f57073
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8P<\x1c') # 0xc8503c1c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xf3\xd4\xfa') # 0x36f3d4fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_delay_time))
data.write(b';\xb9\x9cx') # 0x3bb99c78
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_actor_collision))
data.write(b'_\xa0 \xff') # 0x5fa020ff
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.turn_at_bounds))
data.write(b'\x01UX\xf8') # 0x15558f8
data.write(b'\x00\x04') # size
self.direction_control.to_stream(data)
data.write(b'\xae\xb9qW') # 0xaeb97157
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.jump_when_player_jumps))
data.write(b'#\xcbDv') # 0x23cb4476
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.jump_when_bumping_wall))
data.write(b'W\x18U\xa7') # 0x571855a7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_tar_inhibited_players))
data.write(b'\xe9\xe0\xbe\xb6') # 0xe9e0beb6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_seek_direction_time))
data.write(b'\xc9F\xd3\xef') # 0xc946d3ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pursuit_distance))
data.write(b'x;8/') # 0x783b382f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverse_base_chance))
data.write(b'\xb2\xf9\x97Y') # 0xb2f99759
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reverse_additional_chance))
@classmethod
def from_json(cls, data: dict):
return cls(
bop_jump_type=enums.BopJumpType.from_json(data['bop_jump_type']),
number_of_jumps=data['number_of_jumps'],
jump1=BopJumpData.from_json(data['jump1']),
jump2=BopJumpData.from_json(data['jump2']),
jump3=BopJumpData.from_json(data['jump3']),
jump4=BopJumpData.from_json(data['jump4']),
jump5=BopJumpData.from_json(data['jump5']),
jump_delay_time=data['jump_delay_time'],
no_actor_collision=data['no_actor_collision'],
turn_at_bounds=data['turn_at_bounds'],
direction_control=enums.DirectionControl.from_json(data['direction_control']),
jump_when_player_jumps=data['jump_when_player_jumps'],
jump_when_bumping_wall=data['jump_when_bumping_wall'],
ignore_tar_inhibited_players=data['ignore_tar_inhibited_players'],
minimum_seek_direction_time=data['minimum_seek_direction_time'],
pursuit_distance=data['pursuit_distance'],
reverse_base_chance=data['reverse_base_chance'],
reverse_additional_chance=data['reverse_additional_chance'],
)
def to_json(self) -> dict:
return {
'bop_jump_type': self.bop_jump_type.to_json(),
'number_of_jumps': self.number_of_jumps,
'jump1': self.jump1.to_json(),
'jump2': self.jump2.to_json(),
'jump3': self.jump3.to_json(),
'jump4': self.jump4.to_json(),
'jump5': self.jump5.to_json(),
'jump_delay_time': self.jump_delay_time,
'no_actor_collision': self.no_actor_collision,
'turn_at_bounds': self.turn_at_bounds,
'direction_control': self.direction_control.to_json(),
'jump_when_player_jumps': self.jump_when_player_jumps,
'jump_when_bumping_wall': self.jump_when_bumping_wall,
'ignore_tar_inhibited_players': self.ignore_tar_inhibited_players,
'minimum_seek_direction_time': self.minimum_seek_direction_time,
'pursuit_distance': self.pursuit_distance,
'reverse_base_chance': self.reverse_base_chance,
'reverse_additional_chance': self.reverse_additional_chance,
}
def _decode_bop_jump_type(data: typing.BinaryIO, property_size: int):
return enums.BopJumpType.from_stream(data)
def _decode_number_of_jumps(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_jump1(data: typing.BinaryIO, property_size: int):
return BopJumpData.from_stream(data, property_size)
def _decode_jump2(data: typing.BinaryIO, property_size: int):
return BopJumpData.from_stream(data, property_size, default_override={'height': 2.0, 'distance': 1.0})
def _decode_jump3(data: typing.BinaryIO, property_size: int):
return BopJumpData.from_stream(data, property_size)
def _decode_jump4(data: typing.BinaryIO, property_size: int):
return BopJumpData.from_stream(data, property_size)
def _decode_jump5(data: typing.BinaryIO, property_size: int):
return BopJumpData.from_stream(data, property_size)
def _decode_jump_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_no_actor_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_turn_at_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_direction_control(data: typing.BinaryIO, property_size: int):
return enums.DirectionControl.from_stream(data)
def _decode_jump_when_player_jumps(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_jump_when_bumping_wall(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_tar_inhibited_players(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_seek_direction_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pursuit_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverse_base_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverse_additional_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x76e170ef: ('bop_jump_type', _decode_bop_jump_type),
0xf2b3c5a1: ('number_of_jumps', _decode_number_of_jumps),
0xcb560763: ('jump1', _decode_jump1),
0xbcc8d593: ('jump2', _decode_jump2),
0x276d99fc: ('jump3', _decode_jump3),
0x53f57073: ('jump4', _decode_jump4),
0xc8503c1c: ('jump5', _decode_jump5),
0x36f3d4fa: ('jump_delay_time', _decode_jump_delay_time),
0x3bb99c78: ('no_actor_collision', _decode_no_actor_collision),
0x5fa020ff: ('turn_at_bounds', _decode_turn_at_bounds),
0x15558f8: ('direction_control', _decode_direction_control),
0xaeb97157: ('jump_when_player_jumps', _decode_jump_when_player_jumps),
0x23cb4476: ('jump_when_bumping_wall', _decode_jump_when_bumping_wall),
0x571855a7: ('ignore_tar_inhibited_players', _decode_ignore_tar_inhibited_players),
0xe9e0beb6: ('minimum_seek_direction_time', _decode_minimum_seek_direction_time),
0xc946d3ef: ('pursuit_distance', _decode_pursuit_distance),
0x783b382f: ('reverse_base_chance', _decode_reverse_base_chance),
0xb2f99759: ('reverse_additional_chance', _decode_reverse_additional_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BopJumpBehaviorData.py | 0.567098 | 0.502808 | BopJumpBehaviorData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct142(BaseProperty):
unknown_0x0100cedd: bool = dataclasses.field(default=False)
disable_cling: bool = dataclasses.field(default=False)
unknown_0x12aada70: bool = dataclasses.field(default=False)
disable_grab_barrel: bool = dataclasses.field(default=False)
disable_ground_pound: bool = dataclasses.field(default=False)
disable_jump: bool = dataclasses.field(default=False)
disable_movement: bool = dataclasses.field(default=False)
disable_peanut_gun: bool = dataclasses.field(default=False)
unknown_0x8e028566: bool = dataclasses.field(default=False)
disable_swing: bool = dataclasses.field(default=False)
disable_turns: bool = dataclasses.field(default=False)
disable_offscreen_indicator: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\x01\x00\xce\xdd') # 0x100cedd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0100cedd))
data.write(b'"\x19_\xbb') # 0x22195fbb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_cling))
data.write(b'\x12\xaa\xdap') # 0x12aada70
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x12aada70))
data.write(b'e!6\xc9') # 0x652136c9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_grab_barrel))
data.write(b'y\xb8eb') # 0x79b86562
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_ground_pound))
data.write(b'\x14\x0e\x99\xc2') # 0x140e99c2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_jump))
data.write(b'9^\xffj') # 0x395eff6a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_movement))
data.write(b'\xa5\xac\xe7\x99') # 0xa5ace799
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_peanut_gun))
data.write(b'\x8e\x02\x85f') # 0x8e028566
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8e028566))
data.write(b'\xaf\x080\xb7') # 0xaf0830b7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_swing))
data.write(b'y\xf5\xa3u') # 0x79f5a375
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_turns))
data.write(b'\xdbVP1') # 0xdb565031
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_offscreen_indicator))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x0100cedd=data['unknown_0x0100cedd'],
disable_cling=data['disable_cling'],
unknown_0x12aada70=data['unknown_0x12aada70'],
disable_grab_barrel=data['disable_grab_barrel'],
disable_ground_pound=data['disable_ground_pound'],
disable_jump=data['disable_jump'],
disable_movement=data['disable_movement'],
disable_peanut_gun=data['disable_peanut_gun'],
unknown_0x8e028566=data['unknown_0x8e028566'],
disable_swing=data['disable_swing'],
disable_turns=data['disable_turns'],
disable_offscreen_indicator=data['disable_offscreen_indicator'],
)
def to_json(self) -> dict:
return {
'unknown_0x0100cedd': self.unknown_0x0100cedd,
'disable_cling': self.disable_cling,
'unknown_0x12aada70': self.unknown_0x12aada70,
'disable_grab_barrel': self.disable_grab_barrel,
'disable_ground_pound': self.disable_ground_pound,
'disable_jump': self.disable_jump,
'disable_movement': self.disable_movement,
'disable_peanut_gun': self.disable_peanut_gun,
'unknown_0x8e028566': self.unknown_0x8e028566,
'disable_swing': self.disable_swing,
'disable_turns': self.disable_turns,
'disable_offscreen_indicator': self.disable_offscreen_indicator,
}
_FAST_FORMAT = None
_FAST_IDS = (0x100cedd, 0x22195fbb, 0x12aada70, 0x652136c9, 0x79b86562, 0x140e99c2, 0x395eff6a, 0xa5ace799, 0x8e028566, 0xaf0830b7, 0x79f5a375, 0xdb565031)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct142]:
if property_count != 12:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(84))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct142(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
)
def _decode_unknown_0x0100cedd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_cling(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x12aada70(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_grab_barrel(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_ground_pound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_jump(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_movement(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_peanut_gun(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x8e028566(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_swing(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_turns(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_offscreen_indicator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x100cedd: ('unknown_0x0100cedd', _decode_unknown_0x0100cedd),
0x22195fbb: ('disable_cling', _decode_disable_cling),
0x12aada70: ('unknown_0x12aada70', _decode_unknown_0x12aada70),
0x652136c9: ('disable_grab_barrel', _decode_disable_grab_barrel),
0x79b86562: ('disable_ground_pound', _decode_disable_ground_pound),
0x140e99c2: ('disable_jump', _decode_disable_jump),
0x395eff6a: ('disable_movement', _decode_disable_movement),
0xa5ace799: ('disable_peanut_gun', _decode_disable_peanut_gun),
0x8e028566: ('unknown_0x8e028566', _decode_unknown_0x8e028566),
0xaf0830b7: ('disable_swing', _decode_disable_swing),
0x79f5a375: ('disable_turns', _decode_disable_turns),
0xdb565031: ('disable_offscreen_indicator', _decode_disable_offscreen_indicator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct142.py | 0.582372 | 0.263836 | UnknownStruct142.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerJumpAnimWeights(BaseProperty):
animation_count: int = dataclasses.field(default=0)
random_weight1: float = dataclasses.field(default=0.0)
random_weight2: float = dataclasses.field(default=0.0)
random_weight3: float = dataclasses.field(default=0.0)
random_weight4: float = dataclasses.field(default=0.0)
random_weight5: float = dataclasses.field(default=0.0)
random_weight6: float = dataclasses.field(default=0.0)
random_weight7: float = dataclasses.field(default=0.0)
random_weight8: float = dataclasses.field(default=0.0)
random_weight9: float = dataclasses.field(default=0.0)
random_weight10: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'9\xe9\xfa5') # 0x39e9fa35
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation_count))
data.write(b'\x18RI\xcf') # 0x185249cf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight1))
data.write(b'\x9e\xc6;a') # 0x9ec63b61
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight2))
data.write(b'U\x9a\xe8\xc4') # 0x559ae8c4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight3))
data.write(b'H\x9f\xd8|') # 0x489fd87c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight4))
data.write(b'\x83\xc3\x0b\xd9') # 0x83c30bd9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight5))
data.write(b'\x05Wyw') # 0x5577977
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight6))
data.write(b'\xce\x0b\xaa\xd2') # 0xce0baad2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight7))
data.write(b'?]\x18\x07') # 0x3f5d1807
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight8))
data.write(b'\xf4\x01\xcb\xa2') # 0xf401cba2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight9))
data.write(b'\xe3R\xaf\xf6') # 0xe352aff6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_weight10))
@classmethod
def from_json(cls, data: dict):
return cls(
animation_count=data['animation_count'],
random_weight1=data['random_weight1'],
random_weight2=data['random_weight2'],
random_weight3=data['random_weight3'],
random_weight4=data['random_weight4'],
random_weight5=data['random_weight5'],
random_weight6=data['random_weight6'],
random_weight7=data['random_weight7'],
random_weight8=data['random_weight8'],
random_weight9=data['random_weight9'],
random_weight10=data['random_weight10'],
)
def to_json(self) -> dict:
return {
'animation_count': self.animation_count,
'random_weight1': self.random_weight1,
'random_weight2': self.random_weight2,
'random_weight3': self.random_weight3,
'random_weight4': self.random_weight4,
'random_weight5': self.random_weight5,
'random_weight6': self.random_weight6,
'random_weight7': self.random_weight7,
'random_weight8': self.random_weight8,
'random_weight9': self.random_weight9,
'random_weight10': self.random_weight10,
}
_FAST_FORMAT = None
_FAST_IDS = (0x39e9fa35, 0x185249cf, 0x9ec63b61, 0x559ae8c4, 0x489fd87c, 0x83c30bd9, 0x5577977, 0xce0baad2, 0x3f5d1807, 0xf401cba2, 0xe352aff6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerJumpAnimWeights]:
if property_count != 11:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(110))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30]) != _FAST_IDS:
data.seek(before)
return None
return PlayerJumpAnimWeights(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
)
def _decode_animation_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_random_weight1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_weight10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x39e9fa35: ('animation_count', _decode_animation_count),
0x185249cf: ('random_weight1', _decode_random_weight1),
0x9ec63b61: ('random_weight2', _decode_random_weight2),
0x559ae8c4: ('random_weight3', _decode_random_weight3),
0x489fd87c: ('random_weight4', _decode_random_weight4),
0x83c30bd9: ('random_weight5', _decode_random_weight5),
0x5577977: ('random_weight6', _decode_random_weight6),
0xce0baad2: ('random_weight7', _decode_random_weight7),
0x3f5d1807: ('random_weight8', _decode_random_weight8),
0xf401cba2: ('random_weight9', _decode_random_weight9),
0xe352aff6: ('random_weight10', _decode_random_weight10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerJumpAnimWeights.py | 0.647018 | 0.287699 | PlayerJumpAnimWeights.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.MoleCartStruct import MoleCartStruct
@dataclasses.dataclass()
class UnknownStruct229(BaseProperty):
num_sounds: int = dataclasses.field(default=2)
mole_cart_struct_0x5df3f980: MoleCartStruct = dataclasses.field(default_factory=MoleCartStruct)
mole_cart_struct_0x2b16c0bd: MoleCartStruct = dataclasses.field(default_factory=MoleCartStruct)
mole_cart_struct_0xb0652a69: MoleCartStruct = dataclasses.field(default_factory=MoleCartStruct)
mole_cart_struct_0xc6dcb2c7: MoleCartStruct = dataclasses.field(default_factory=MoleCartStruct)
mole_cart_struct_0x5daf5813: MoleCartStruct = dataclasses.field(default_factory=MoleCartStruct)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xc6\x86\xafQ') # 0xc686af51
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_sounds))
data.write(b']\xf3\xf9\x80') # 0x5df3f980
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_cart_struct_0x5df3f980.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+\x16\xc0\xbd') # 0x2b16c0bd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_cart_struct_0x2b16c0bd.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0e*i') # 0xb0652a69
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_cart_struct_0xb0652a69.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xdc\xb2\xc7') # 0xc6dcb2c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_cart_struct_0xc6dcb2c7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']\xafX\x13') # 0x5daf5813
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_cart_struct_0x5daf5813.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
num_sounds=data['num_sounds'],
mole_cart_struct_0x5df3f980=MoleCartStruct.from_json(data['mole_cart_struct_0x5df3f980']),
mole_cart_struct_0x2b16c0bd=MoleCartStruct.from_json(data['mole_cart_struct_0x2b16c0bd']),
mole_cart_struct_0xb0652a69=MoleCartStruct.from_json(data['mole_cart_struct_0xb0652a69']),
mole_cart_struct_0xc6dcb2c7=MoleCartStruct.from_json(data['mole_cart_struct_0xc6dcb2c7']),
mole_cart_struct_0x5daf5813=MoleCartStruct.from_json(data['mole_cart_struct_0x5daf5813']),
)
def to_json(self) -> dict:
return {
'num_sounds': self.num_sounds,
'mole_cart_struct_0x5df3f980': self.mole_cart_struct_0x5df3f980.to_json(),
'mole_cart_struct_0x2b16c0bd': self.mole_cart_struct_0x2b16c0bd.to_json(),
'mole_cart_struct_0xb0652a69': self.mole_cart_struct_0xb0652a69.to_json(),
'mole_cart_struct_0xc6dcb2c7': self.mole_cart_struct_0xc6dcb2c7.to_json(),
'mole_cart_struct_0x5daf5813': self.mole_cart_struct_0x5daf5813.to_json(),
}
def _decode_num_sounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mole_cart_struct_0x5df3f980(data: typing.BinaryIO, property_size: int):
return MoleCartStruct.from_stream(data, property_size)
def _decode_mole_cart_struct_0x2b16c0bd(data: typing.BinaryIO, property_size: int):
return MoleCartStruct.from_stream(data, property_size)
def _decode_mole_cart_struct_0xb0652a69(data: typing.BinaryIO, property_size: int):
return MoleCartStruct.from_stream(data, property_size)
def _decode_mole_cart_struct_0xc6dcb2c7(data: typing.BinaryIO, property_size: int):
return MoleCartStruct.from_stream(data, property_size)
def _decode_mole_cart_struct_0x5daf5813(data: typing.BinaryIO, property_size: int):
return MoleCartStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc686af51: ('num_sounds', _decode_num_sounds),
0x5df3f980: ('mole_cart_struct_0x5df3f980', _decode_mole_cart_struct_0x5df3f980),
0x2b16c0bd: ('mole_cart_struct_0x2b16c0bd', _decode_mole_cart_struct_0x2b16c0bd),
0xb0652a69: ('mole_cart_struct_0xb0652a69', _decode_mole_cart_struct_0xb0652a69),
0xc6dcb2c7: ('mole_cart_struct_0xc6dcb2c7', _decode_mole_cart_struct_0xc6dcb2c7),
0x5daf5813: ('mole_cart_struct_0x5daf5813', _decode_mole_cart_struct_0x5daf5813),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct229.py | 0.565059 | 0.340622 | UnknownStruct229.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.AreaDamageData import AreaDamageData
@dataclasses.dataclass()
class UnknownStruct133(BaseProperty):
number_of_area_damages: int = dataclasses.field(default=0)
area_damage1: AreaDamageData = dataclasses.field(default_factory=AreaDamageData)
area_damage2: AreaDamageData = dataclasses.field(default_factory=AreaDamageData)
area_damage3: AreaDamageData = dataclasses.field(default_factory=AreaDamageData)
area_damage4: AreaDamageData = dataclasses.field(default_factory=AreaDamageData)
area_damage5: AreaDamageData = dataclasses.field(default_factory=AreaDamageData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'M*\xf7\xb7') # 0x4d2af7b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_area_damages))
data.write(b'\xd768/') # 0xd736382f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6KRV') # 0xc64b5256
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7f\xb0\x89\xbe') # 0x7fb089be
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4\xb1\x86\xa4') # 0xe4b186a4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']J]L') # 0x5d4a5d4c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_damage5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_area_damages=data['number_of_area_damages'],
area_damage1=AreaDamageData.from_json(data['area_damage1']),
area_damage2=AreaDamageData.from_json(data['area_damage2']),
area_damage3=AreaDamageData.from_json(data['area_damage3']),
area_damage4=AreaDamageData.from_json(data['area_damage4']),
area_damage5=AreaDamageData.from_json(data['area_damage5']),
)
def to_json(self) -> dict:
return {
'number_of_area_damages': self.number_of_area_damages,
'area_damage1': self.area_damage1.to_json(),
'area_damage2': self.area_damage2.to_json(),
'area_damage3': self.area_damage3.to_json(),
'area_damage4': self.area_damage4.to_json(),
'area_damage5': self.area_damage5.to_json(),
}
def _decode_number_of_area_damages(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_area_damage1(data: typing.BinaryIO, property_size: int):
return AreaDamageData.from_stream(data, property_size)
def _decode_area_damage2(data: typing.BinaryIO, property_size: int):
return AreaDamageData.from_stream(data, property_size)
def _decode_area_damage3(data: typing.BinaryIO, property_size: int):
return AreaDamageData.from_stream(data, property_size)
def _decode_area_damage4(data: typing.BinaryIO, property_size: int):
return AreaDamageData.from_stream(data, property_size)
def _decode_area_damage5(data: typing.BinaryIO, property_size: int):
return AreaDamageData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4d2af7b7: ('number_of_area_damages', _decode_number_of_area_damages),
0xd736382f: ('area_damage1', _decode_area_damage1),
0xc64b5256: ('area_damage2', _decode_area_damage2),
0x7fb089be: ('area_damage3', _decode_area_damage3),
0xe4b186a4: ('area_damage4', _decode_area_damage4),
0x5d4a5d4c: ('area_damage5', _decode_area_damage5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct133.py | 0.582491 | 0.309702 | UnknownStruct133.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class BouncyTireJumpHeights(BaseProperty):
min_jump_height: float = dataclasses.field(default=4.640200138092041)
max_jump_height: float = dataclasses.field(default=7.640200138092041)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'"9\x8aO') # 0x22398a4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_jump_height))
data.write(b'q\x9f\x92\xab') # 0x719f92ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_jump_height))
@classmethod
def from_json(cls, data: dict):
return cls(
min_jump_height=data['min_jump_height'],
max_jump_height=data['max_jump_height'],
)
def to_json(self) -> dict:
return {
'min_jump_height': self.min_jump_height,
'max_jump_height': self.max_jump_height,
}
_FAST_FORMAT = None
_FAST_IDS = (0x22398a4f, 0x719f92ab)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BouncyTireJumpHeights]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return BouncyTireJumpHeights(
dec[2],
dec[5],
)
def _decode_min_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x22398a4f: ('min_jump_height', _decode_min_jump_height),
0x719f92ab: ('max_jump_height', _decode_max_jump_height),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BouncyTireJumpHeights.py | 0.641198 | 0.301613 | BouncyTireJumpHeights.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct266 import UnknownStruct266
@dataclasses.dataclass()
class UnknownStruct267(BaseProperty):
unknown_struct266: UnknownStruct266 = dataclasses.field(default_factory=UnknownStruct266)
unknown: UnknownStruct266 = dataclasses.field(default_factory=UnknownStruct266)
min_anim_rate: float = dataclasses.field(default=1.0)
max_anim_rate: float = dataclasses.field(default=2.0)
stick_to_max: bool = dataclasses.field(default=False)
loop_forward: bool = dataclasses.field(default=False)
loop_backwards: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'i\xb1\xed\xe1') # 0x69b1ede1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct266.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b#7K') # 0x1b23374b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6\xfeR\xe5') # 0xe6fe52e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_anim_rate))
data.write(b'\xb7\x07\xe9\xb8') # 0xb707e9b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_anim_rate))
data.write(b"'\xcf\x0f\xe0") # 0x27cf0fe0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stick_to_max))
data.write(b'e/\xb7\xd2') # 0x652fb7d2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_forward))
data.write(b'\x91\x8d&\xbe') # 0x918d26be
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_backwards))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct266=UnknownStruct266.from_json(data['unknown_struct266']),
unknown=UnknownStruct266.from_json(data['unknown']),
min_anim_rate=data['min_anim_rate'],
max_anim_rate=data['max_anim_rate'],
stick_to_max=data['stick_to_max'],
loop_forward=data['loop_forward'],
loop_backwards=data['loop_backwards'],
)
def to_json(self) -> dict:
return {
'unknown_struct266': self.unknown_struct266.to_json(),
'unknown': self.unknown.to_json(),
'min_anim_rate': self.min_anim_rate,
'max_anim_rate': self.max_anim_rate,
'stick_to_max': self.stick_to_max,
'loop_forward': self.loop_forward,
'loop_backwards': self.loop_backwards,
}
def _decode_unknown_struct266(data: typing.BinaryIO, property_size: int):
return UnknownStruct266.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return UnknownStruct266.from_stream(data, property_size)
def _decode_min_anim_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_anim_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stick_to_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_forward(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_backwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x69b1ede1: ('unknown_struct266', _decode_unknown_struct266),
0x1b23374b: ('unknown', _decode_unknown),
0xe6fe52e5: ('min_anim_rate', _decode_min_anim_rate),
0xb707e9b8: ('max_anim_rate', _decode_max_anim_rate),
0x27cf0fe0: ('stick_to_max', _decode_stick_to_max),
0x652fb7d2: ('loop_forward', _decode_loop_forward),
0x918d26be: ('loop_backwards', _decode_loop_backwards),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct267.py | 0.616128 | 0.282641 | UnknownStruct267.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct64(BaseProperty):
acceleration: float = dataclasses.field(default=50.0)
deceleration: float = dataclasses.field(default=30.0)
maximum_speed: float = dataclasses.field(default=60.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x9e\xc4\xfc\x10') # 0x9ec4fc10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deceleration))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
acceleration=data['acceleration'],
deceleration=data['deceleration'],
maximum_speed=data['maximum_speed'],
)
def to_json(self) -> dict:
return {
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'maximum_speed': self.maximum_speed,
}
_FAST_FORMAT = None
_FAST_IDS = (0x39fb7978, 0x9ec4fc10, 0x140ef2cc)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct64]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct64(
dec[2],
dec[5],
dec[8],
)
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct64.py | 0.788176 | 0.334195 | UnknownStruct64.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class HealthInfo(BaseProperty):
health: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
@classmethod
def from_json(cls, data: dict):
return cls(
health=data['health'],
)
def to_json(self) -> dict:
return {
'health': self.health,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf0668919)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HealthInfo]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return HealthInfo(
dec[2],
)
def _decode_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf0668919: ('health', _decode_health),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/HealthInfo.py | 0.616936 | 0.313 | HealthInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class UnknownStruct86(BaseProperty):
unknown: bool = dataclasses.field(default=True)
movement_speed: float = dataclasses.field(default=1.0)
locomotion_speed: enums.LocomotionSpeed = dataclasses.field(default=enums.LocomotionSpeed.Unknown1)
start_turn_distance: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'R\xf2\xec\x16') # 0x52f2ec16
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'Ao\x15\xe8') # 0x416f15e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.movement_speed))
data.write(b'\x8c\xeb\xeb\x1e') # 0x8cebeb1e
data.write(b'\x00\x04') # size
self.locomotion_speed.to_stream(data)
data.write(b'\xf5r%k') # 0xf572256b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_turn_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
movement_speed=data['movement_speed'],
locomotion_speed=enums.LocomotionSpeed.from_json(data['locomotion_speed']),
start_turn_distance=data['start_turn_distance'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'movement_speed': self.movement_speed,
'locomotion_speed': self.locomotion_speed.to_json(),
'start_turn_distance': self.start_turn_distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0x52f2ec16, 0x416f15e8, 0x8cebeb1e, 0xf572256b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct86]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHLLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(37))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct86(
dec[2],
dec[5],
enums.LocomotionSpeed(dec[8]),
dec[11],
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_movement_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_locomotion_speed(data: typing.BinaryIO, property_size: int):
return enums.LocomotionSpeed.from_stream(data)
def _decode_start_turn_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x52f2ec16: ('unknown', _decode_unknown),
0x416f15e8: ('movement_speed', _decode_movement_speed),
0x8cebeb1e: ('locomotion_speed', _decode_locomotion_speed),
0xf572256b: ('start_turn_distance', _decode_start_turn_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct86.py | 0.679391 | 0.312868 | UnknownStruct86.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct165(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_0xe9ae9114: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0x8f321be8: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
core_text_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0xc022b7a6: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0xcc4eb20d: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
background_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b'\xe9\xae\x91\x14') # 0xe9ae9114
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xe9ae9114))
data.write(b'\x8f2\x1b\xe8') # 0x8f321be8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x8f321be8))
data.write(b'\xe7W d') # 0xe7572064
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.core_text_string))
data.write(b'\xc0"\xb7\xa6') # 0xc022b7a6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xc022b7a6))
data.write(b'\xccN\xb2\r') # 0xcc4eb20d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xcc4eb20d))
data.write(b'\xf7\xe6u\xfe') # 0xf7e675fe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.background_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
gui_frame=data['gui_frame'],
unknown_0xe9ae9114=data['unknown_0xe9ae9114'],
unknown_0x8f321be8=data['unknown_0x8f321be8'],
core_text_string=data['core_text_string'],
unknown_0xc022b7a6=data['unknown_0xc022b7a6'],
unknown_0xcc4eb20d=data['unknown_0xcc4eb20d'],
background_sound=data['background_sound'],
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_0xe9ae9114': self.unknown_0xe9ae9114,
'unknown_0x8f321be8': self.unknown_0x8f321be8,
'core_text_string': self.core_text_string,
'unknown_0xc022b7a6': self.unknown_0xc022b7a6,
'unknown_0xcc4eb20d': self.unknown_0xcc4eb20d,
'background_sound': self.background_sound,
}
_FAST_FORMAT = None
_FAST_IDS = (0x806052cb, 0xe9ae9114, 0x8f321be8, 0xe7572064, 0xc022b7a6, 0xcc4eb20d, 0xf7e675fe)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct165]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(98))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct165(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xe9ae9114(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x8f321be8(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_core_text_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xc022b7a6(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xcc4eb20d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_background_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0xe9ae9114: ('unknown_0xe9ae9114', _decode_unknown_0xe9ae9114),
0x8f321be8: ('unknown_0x8f321be8', _decode_unknown_0x8f321be8),
0xe7572064: ('core_text_string', _decode_core_text_string),
0xc022b7a6: ('unknown_0xc022b7a6', _decode_unknown_0xc022b7a6),
0xcc4eb20d: ('unknown_0xcc4eb20d', _decode_unknown_0xcc4eb20d),
0xf7e675fe: ('background_sound', _decode_background_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct165.py | 0.5564 | 0.202621 | UnknownStruct165.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct276(BaseProperty):
unknown: Spline = dataclasses.field(default_factory=Spline)
pound_disable_time: float = dataclasses.field(default=5.0)
launch_delay: float = dataclasses.field(default=4.0)
target_height: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'*\x8f\xd6\xd0') # 0x2a8fd6d0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xee\x96\x87') # 0x95ee9687
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pound_disable_time))
data.write(b'FU\xa9\xc5') # 0x4655a9c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.launch_delay))
data.write(b'\xbd\xba\x19\x1e') # 0xbdba191e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_height))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=Spline.from_json(data['unknown']),
pound_disable_time=data['pound_disable_time'],
launch_delay=data['launch_delay'],
target_height=data['target_height'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown.to_json(),
'pound_disable_time': self.pound_disable_time,
'launch_delay': self.launch_delay,
'target_height': self.target_height,
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pound_disable_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_launch_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2a8fd6d0: ('unknown', _decode_unknown),
0x95ee9687: ('pound_disable_time', _decode_pound_disable_time),
0x4655a9c5: ('launch_delay', _decode_launch_delay),
0xbdba191e: ('target_height', _decode_target_height),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct276.py | 0.639849 | 0.277741 | UnknownStruct276.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class ProportionalConvergence(BaseProperty):
velocity: float = dataclasses.field(default=0.0)
dampening_control: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x02\xf0\x16\x83') # 0x2f01683
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.velocity))
data.write(b'\xf7\xfb\xa2\xbf') # 0xf7fba2bf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dampening_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
velocity=data['velocity'],
dampening_control=Spline.from_json(data['dampening_control']),
)
def to_json(self) -> dict:
return {
'velocity': self.velocity,
'dampening_control': self.dampening_control.to_json(),
}
def _decode_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dampening_control(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f01683: ('velocity', _decode_velocity),
0xf7fba2bf: ('dampening_control', _decode_dampening_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProportionalConvergence.py | 0.663015 | 0.298971 | ProportionalConvergence.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.RobotChickenStructB import RobotChickenStructB
@dataclasses.dataclass()
class UnknownStruct258(BaseProperty):
attack_selector: enums.RobotChickenEnum = dataclasses.field(default=enums.RobotChickenEnum.Unknown1)
health: float = dataclasses.field(default=3.0)
static_hazard: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
robot_chicken_struct_b_0x8bfefc72: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
robot_chicken_struct_b_0x108d16a6: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
robot_chicken_struct_b_0x66348e08: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
robot_chicken_struct_b_0xfd4764dc: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
robot_chicken_struct_b_0x8ba25de1: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
robot_chicken_struct_b_0x10d1b735: RobotChickenStructB = dataclasses.field(default_factory=RobotChickenStructB)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x97\xd3\x0f\x8b') # 0x97d30f8b
data.write(b'\x00\x04') # size
self.attack_selector.to_stream(data)
data.write(b'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
data.write(b'\xfd\x1b\xc5O') # 0xfd1bc54f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.static_hazard.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xfe\xfcr') # 0x8bfefc72
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_b_0x8bfefc72.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10\x8d\x16\xa6') # 0x108d16a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_b_0x108d16a6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f4\x8e\x08') # 0x66348e08
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_b_0x66348e08.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfdGd\xdc') # 0xfd4764dc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_b_0xfd4764dc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xa2]\xe1') # 0x8ba25de1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_b_0x8ba25de1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10\xd1\xb75') # 0x10d1b735
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_b_0x10d1b735.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
attack_selector=enums.RobotChickenEnum.from_json(data['attack_selector']),
health=data['health'],
static_hazard=RobotChickenStructB.from_json(data['static_hazard']),
robot_chicken_struct_b_0x8bfefc72=RobotChickenStructB.from_json(data['robot_chicken_struct_b_0x8bfefc72']),
robot_chicken_struct_b_0x108d16a6=RobotChickenStructB.from_json(data['robot_chicken_struct_b_0x108d16a6']),
robot_chicken_struct_b_0x66348e08=RobotChickenStructB.from_json(data['robot_chicken_struct_b_0x66348e08']),
robot_chicken_struct_b_0xfd4764dc=RobotChickenStructB.from_json(data['robot_chicken_struct_b_0xfd4764dc']),
robot_chicken_struct_b_0x8ba25de1=RobotChickenStructB.from_json(data['robot_chicken_struct_b_0x8ba25de1']),
robot_chicken_struct_b_0x10d1b735=RobotChickenStructB.from_json(data['robot_chicken_struct_b_0x10d1b735']),
)
def to_json(self) -> dict:
return {
'attack_selector': self.attack_selector.to_json(),
'health': self.health,
'static_hazard': self.static_hazard.to_json(),
'robot_chicken_struct_b_0x8bfefc72': self.robot_chicken_struct_b_0x8bfefc72.to_json(),
'robot_chicken_struct_b_0x108d16a6': self.robot_chicken_struct_b_0x108d16a6.to_json(),
'robot_chicken_struct_b_0x66348e08': self.robot_chicken_struct_b_0x66348e08.to_json(),
'robot_chicken_struct_b_0xfd4764dc': self.robot_chicken_struct_b_0xfd4764dc.to_json(),
'robot_chicken_struct_b_0x8ba25de1': self.robot_chicken_struct_b_0x8ba25de1.to_json(),
'robot_chicken_struct_b_0x10d1b735': self.robot_chicken_struct_b_0x10d1b735.to_json(),
}
def _decode_attack_selector(data: typing.BinaryIO, property_size: int):
return enums.RobotChickenEnum.from_stream(data)
def _decode_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_static_hazard(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
def _decode_robot_chicken_struct_b_0x8bfefc72(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
def _decode_robot_chicken_struct_b_0x108d16a6(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
def _decode_robot_chicken_struct_b_0x66348e08(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
def _decode_robot_chicken_struct_b_0xfd4764dc(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
def _decode_robot_chicken_struct_b_0x8ba25de1(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
def _decode_robot_chicken_struct_b_0x10d1b735(data: typing.BinaryIO, property_size: int):
return RobotChickenStructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x97d30f8b: ('attack_selector', _decode_attack_selector),
0xf0668919: ('health', _decode_health),
0xfd1bc54f: ('static_hazard', _decode_static_hazard),
0x8bfefc72: ('robot_chicken_struct_b_0x8bfefc72', _decode_robot_chicken_struct_b_0x8bfefc72),
0x108d16a6: ('robot_chicken_struct_b_0x108d16a6', _decode_robot_chicken_struct_b_0x108d16a6),
0x66348e08: ('robot_chicken_struct_b_0x66348e08', _decode_robot_chicken_struct_b_0x66348e08),
0xfd4764dc: ('robot_chicken_struct_b_0xfd4764dc', _decode_robot_chicken_struct_b_0xfd4764dc),
0x8ba25de1: ('robot_chicken_struct_b_0x8ba25de1', _decode_robot_chicken_struct_b_0x8ba25de1),
0x10d1b735: ('robot_chicken_struct_b_0x10d1b735', _decode_robot_chicken_struct_b_0x10d1b735),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct258.py | 0.499023 | 0.333883 | UnknownStruct258.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.DamageEffectData import DamageEffectData
@dataclasses.dataclass()
class ProjectileBehaviorData(BaseProperty):
disable_collision_time_after_creation: float = dataclasses.field(default=0.5)
mode: int = dataclasses.field(default=547879193) # Choice
launch_up_speed: float = dataclasses.field(default=0.0)
target_speed_multiplier: float = dataclasses.field(default=1.0)
extra_distance_past_target_point: float = dataclasses.field(default=0.0)
max_spline_distance_from_starting_point: float = dataclasses.field(default=0.0)
reverse_direction_when_target_is_thrown: bool = dataclasses.field(default=False)
max_life_time: float = dataclasses.field(default=5.0)
max_life_time_safe_guard: float = dataclasses.field(default=30.0)
number_of_damage_effects: int = dataclasses.field(default=0)
align_damage_effects_to_surface_on_creation: bool = dataclasses.field(default=False)
allow_damage_effects_to_slave_to_platforms: bool = dataclasses.field(default=False)
damage_effect: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
damage_effect2: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
damage_effect3: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
apply_contact_rules: bool = dataclasses.field(default=False)
ignore_all_but_player: bool = dataclasses.field(default=False)
disable_behavior_after_applying_velocity: bool = dataclasses.field(default=False)
disable_max_life_time: bool = dataclasses.field(default=False)
limit_speed: bool = dataclasses.field(default=False)
maximum_speed: float = dataclasses.field(default=100.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x15') # 21 properties
data.write(b'\xbe\xc9\x90\x05') # 0xbec99005
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_collision_time_after_creation))
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mode))
data.write(b'A\xf0\x9d\xe5') # 0x41f09de5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.launch_up_speed))
data.write(b'>\x88\x17\xaa') # 0x3e8817aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_speed_multiplier))
data.write(b'.\x94\xd9\x8e') # 0x2e94d98e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.extra_distance_past_target_point))
data.write(b'\xe2\x96\xb2\x9f') # 0xe296b29f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_spline_distance_from_starting_point))
data.write(b'\x82\xdb\xfc\xf1') # 0x82dbfcf1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reverse_direction_when_target_is_thrown))
data.write(b'V%oY') # 0x56256f59
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_life_time))
data.write(b'\x17\xe5\x81\x1d') # 0x17e5811d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_life_time_safe_guard))
data.write(b'>Hm\xc0') # 0x3e486dc0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_damage_effects))
data.write(b"*\xcb\xfb'") # 0x2acbfb27
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.align_damage_effects_to_surface_on_creation))
data.write(b'\xe3\xf9j\x88') # 0xe3f96a88
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_damage_effects_to_slave_to_platforms))
data.write(b'>\x01!\xc3') # 0x3e0121c3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7f12\x85') # 0x7f313285
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\x97\xf9\xc6') # 0xf897f9c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S\x185}') # 0x5318357d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_contact_rules))
data.write(b'\xab\x0fQX') # 0xab0f5158
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_all_but_player))
data.write(b'\xb9\xe1I\xe6') # 0xb9e149e6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_behavior_after_applying_velocity))
data.write(b'\xce\xd5\x0fx') # 0xced50f78
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_max_life_time))
data.write(b'\xd0\xe7\xf9`') # 0xd0e7f960
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.limit_speed))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
disable_collision_time_after_creation=data['disable_collision_time_after_creation'],
mode=data['mode'],
launch_up_speed=data['launch_up_speed'],
target_speed_multiplier=data['target_speed_multiplier'],
extra_distance_past_target_point=data['extra_distance_past_target_point'],
max_spline_distance_from_starting_point=data['max_spline_distance_from_starting_point'],
reverse_direction_when_target_is_thrown=data['reverse_direction_when_target_is_thrown'],
max_life_time=data['max_life_time'],
max_life_time_safe_guard=data['max_life_time_safe_guard'],
number_of_damage_effects=data['number_of_damage_effects'],
align_damage_effects_to_surface_on_creation=data['align_damage_effects_to_surface_on_creation'],
allow_damage_effects_to_slave_to_platforms=data['allow_damage_effects_to_slave_to_platforms'],
damage_effect=DamageEffectData.from_json(data['damage_effect']),
damage_effect2=DamageEffectData.from_json(data['damage_effect2']),
damage_effect3=DamageEffectData.from_json(data['damage_effect3']),
apply_contact_rules=data['apply_contact_rules'],
ignore_all_but_player=data['ignore_all_but_player'],
disable_behavior_after_applying_velocity=data['disable_behavior_after_applying_velocity'],
disable_max_life_time=data['disable_max_life_time'],
limit_speed=data['limit_speed'],
maximum_speed=data['maximum_speed'],
)
def to_json(self) -> dict:
return {
'disable_collision_time_after_creation': self.disable_collision_time_after_creation,
'mode': self.mode,
'launch_up_speed': self.launch_up_speed,
'target_speed_multiplier': self.target_speed_multiplier,
'extra_distance_past_target_point': self.extra_distance_past_target_point,
'max_spline_distance_from_starting_point': self.max_spline_distance_from_starting_point,
'reverse_direction_when_target_is_thrown': self.reverse_direction_when_target_is_thrown,
'max_life_time': self.max_life_time,
'max_life_time_safe_guard': self.max_life_time_safe_guard,
'number_of_damage_effects': self.number_of_damage_effects,
'align_damage_effects_to_surface_on_creation': self.align_damage_effects_to_surface_on_creation,
'allow_damage_effects_to_slave_to_platforms': self.allow_damage_effects_to_slave_to_platforms,
'damage_effect': self.damage_effect.to_json(),
'damage_effect2': self.damage_effect2.to_json(),
'damage_effect3': self.damage_effect3.to_json(),
'apply_contact_rules': self.apply_contact_rules,
'ignore_all_but_player': self.ignore_all_but_player,
'disable_behavior_after_applying_velocity': self.disable_behavior_after_applying_velocity,
'disable_max_life_time': self.disable_max_life_time,
'limit_speed': self.limit_speed,
'maximum_speed': self.maximum_speed,
}
def _decode_disable_collision_time_after_creation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_launch_up_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_speed_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_extra_distance_past_target_point(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_spline_distance_from_starting_point(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reverse_direction_when_target_is_thrown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_life_time_safe_guard(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_number_of_damage_effects(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_align_damage_effects_to_surface_on_creation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_damage_effects_to_slave_to_platforms(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damage_effect(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
def _decode_damage_effect2(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
def _decode_damage_effect3(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
def _decode_apply_contact_rules(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_all_but_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_behavior_after_applying_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_max_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_limit_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_maximum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xbec99005: ('disable_collision_time_after_creation', _decode_disable_collision_time_after_creation),
0xb8f60f9a: ('mode', _decode_mode),
0x41f09de5: ('launch_up_speed', _decode_launch_up_speed),
0x3e8817aa: ('target_speed_multiplier', _decode_target_speed_multiplier),
0x2e94d98e: ('extra_distance_past_target_point', _decode_extra_distance_past_target_point),
0xe296b29f: ('max_spline_distance_from_starting_point', _decode_max_spline_distance_from_starting_point),
0x82dbfcf1: ('reverse_direction_when_target_is_thrown', _decode_reverse_direction_when_target_is_thrown),
0x56256f59: ('max_life_time', _decode_max_life_time),
0x17e5811d: ('max_life_time_safe_guard', _decode_max_life_time_safe_guard),
0x3e486dc0: ('number_of_damage_effects', _decode_number_of_damage_effects),
0x2acbfb27: ('align_damage_effects_to_surface_on_creation', _decode_align_damage_effects_to_surface_on_creation),
0xe3f96a88: ('allow_damage_effects_to_slave_to_platforms', _decode_allow_damage_effects_to_slave_to_platforms),
0x3e0121c3: ('damage_effect', _decode_damage_effect),
0x7f313285: ('damage_effect2', _decode_damage_effect2),
0xf897f9c6: ('damage_effect3', _decode_damage_effect3),
0x5318357d: ('apply_contact_rules', _decode_apply_contact_rules),
0xab0f5158: ('ignore_all_but_player', _decode_ignore_all_but_player),
0xb9e149e6: ('disable_behavior_after_applying_velocity', _decode_disable_behavior_after_applying_velocity),
0xced50f78: ('disable_max_life_time', _decode_disable_max_life_time),
0xd0e7f960: ('limit_speed', _decode_limit_speed),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileBehaviorData.py | 0.620737 | 0.3009 | ProjectileBehaviorData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct52(BaseProperty):
distance: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
@classmethod
def from_json(cls, data: dict):
return cls(
distance=data['distance'],
)
def to_json(self) -> dict:
return {
'distance': self.distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc3bf43be)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct52]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct52(
dec[2],
)
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc3bf43be: ('distance', _decode_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct52.py | 0.673621 | 0.312514 | UnknownStruct52.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
@dataclasses.dataclass()
class UnknownStruct77(BaseProperty):
convergence_0xaeb294fd: Convergence = dataclasses.field(default_factory=Convergence)
convergence_0x4a4b9b59: Convergence = dataclasses.field(default_factory=Convergence)
convergence_0xecdaca25: Convergence = dataclasses.field(default_factory=Convergence)
unknown_0x7e69a860: bool = dataclasses.field(default=True)
convergence_0x26bcff37: Convergence = dataclasses.field(default_factory=Convergence)
unknown_0x6c1626b9: float = dataclasses.field(default=4.0)
unknown_0x7a323dda: float = dataclasses.field(default=9.0)
unknown_0x33e6589f: float = dataclasses.field(default=1.0)
unknown_0x1a98a587: float = dataclasses.field(default=4.25)
unknown_0x021f6d9b: float = dataclasses.field(default=12.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\xae\xb2\x94\xfd') # 0xaeb294fd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence_0xaeb294fd.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'JK\x9bY') # 0x4a4b9b59
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence_0x4a4b9b59.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xec\xda\xca%') # 0xecdaca25
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence_0xecdaca25.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~i\xa8`') # 0x7e69a860
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7e69a860))
data.write(b'&\xbc\xff7') # 0x26bcff37
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence_0x26bcff37.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l\x16&\xb9') # 0x6c1626b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6c1626b9))
data.write(b'z2=\xda') # 0x7a323dda
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7a323dda))
data.write(b'3\xe6X\x9f') # 0x33e6589f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x33e6589f))
data.write(b'\x1a\x98\xa5\x87') # 0x1a98a587
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1a98a587))
data.write(b'\x02\x1fm\x9b') # 0x21f6d9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x021f6d9b))
@classmethod
def from_json(cls, data: dict):
return cls(
convergence_0xaeb294fd=Convergence.from_json(data['convergence_0xaeb294fd']),
convergence_0x4a4b9b59=Convergence.from_json(data['convergence_0x4a4b9b59']),
convergence_0xecdaca25=Convergence.from_json(data['convergence_0xecdaca25']),
unknown_0x7e69a860=data['unknown_0x7e69a860'],
convergence_0x26bcff37=Convergence.from_json(data['convergence_0x26bcff37']),
unknown_0x6c1626b9=data['unknown_0x6c1626b9'],
unknown_0x7a323dda=data['unknown_0x7a323dda'],
unknown_0x33e6589f=data['unknown_0x33e6589f'],
unknown_0x1a98a587=data['unknown_0x1a98a587'],
unknown_0x021f6d9b=data['unknown_0x021f6d9b'],
)
def to_json(self) -> dict:
return {
'convergence_0xaeb294fd': self.convergence_0xaeb294fd.to_json(),
'convergence_0x4a4b9b59': self.convergence_0x4a4b9b59.to_json(),
'convergence_0xecdaca25': self.convergence_0xecdaca25.to_json(),
'unknown_0x7e69a860': self.unknown_0x7e69a860,
'convergence_0x26bcff37': self.convergence_0x26bcff37.to_json(),
'unknown_0x6c1626b9': self.unknown_0x6c1626b9,
'unknown_0x7a323dda': self.unknown_0x7a323dda,
'unknown_0x33e6589f': self.unknown_0x33e6589f,
'unknown_0x1a98a587': self.unknown_0x1a98a587,
'unknown_0x021f6d9b': self.unknown_0x021f6d9b,
}
def _decode_convergence_0xaeb294fd(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_convergence_0x4a4b9b59(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_convergence_0xecdaca25(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_unknown_0x7e69a860(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_convergence_0x26bcff37(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_unknown_0x6c1626b9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7a323dda(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x33e6589f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1a98a587(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x021f6d9b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xaeb294fd: ('convergence_0xaeb294fd', _decode_convergence_0xaeb294fd),
0x4a4b9b59: ('convergence_0x4a4b9b59', _decode_convergence_0x4a4b9b59),
0xecdaca25: ('convergence_0xecdaca25', _decode_convergence_0xecdaca25),
0x7e69a860: ('unknown_0x7e69a860', _decode_unknown_0x7e69a860),
0x26bcff37: ('convergence_0x26bcff37', _decode_convergence_0x26bcff37),
0x6c1626b9: ('unknown_0x6c1626b9', _decode_unknown_0x6c1626b9),
0x7a323dda: ('unknown_0x7a323dda', _decode_unknown_0x7a323dda),
0x33e6589f: ('unknown_0x33e6589f', _decode_unknown_0x33e6589f),
0x1a98a587: ('unknown_0x1a98a587', _decode_unknown_0x1a98a587),
0x21f6d9b: ('unknown_0x021f6d9b', _decode_unknown_0x021f6d9b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct77.py | 0.599954 | 0.356223 | UnknownStruct77.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
@dataclasses.dataclass()
class UnknownStruct76(BaseProperty):
motion_type: Convergence = dataclasses.field(default_factory=Convergence)
use_vertical_motion: bool = dataclasses.field(default=False)
convergence: Convergence = dataclasses.field(default_factory=Convergence)
collision_type: enums.CollisionType = dataclasses.field(default=enums.CollisionType.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xc1Tz\xf3') # 0xc1547af3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'}\x0b\xca\x87') # 0x7d0bca87
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_vertical_motion))
data.write(b'\xd9\xa9\x0e\xc3') # 0xd9a90ec3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6t\xea=') # 0xb674ea3d
data.write(b'\x00\x04') # size
self.collision_type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
motion_type=Convergence.from_json(data['motion_type']),
use_vertical_motion=data['use_vertical_motion'],
convergence=Convergence.from_json(data['convergence']),
collision_type=enums.CollisionType.from_json(data['collision_type']),
)
def to_json(self) -> dict:
return {
'motion_type': self.motion_type.to_json(),
'use_vertical_motion': self.use_vertical_motion,
'convergence': self.convergence.to_json(),
'collision_type': self.collision_type.to_json(),
}
def _decode_motion_type(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_use_vertical_motion(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_convergence(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_collision_type(data: typing.BinaryIO, property_size: int):
return enums.CollisionType.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc1547af3: ('motion_type', _decode_motion_type),
0x7d0bca87: ('use_vertical_motion', _decode_use_vertical_motion),
0xd9a90ec3: ('convergence', _decode_convergence),
0xb674ea3d: ('collision_type', _decode_collision_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct76.py | 0.617974 | 0.285691 | UnknownStruct76.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct167(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
select: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD', 'STRG']}, default=default_asset_id)
caud_0x7b084ab6: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
select_diddy_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
select_shield_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
select_heart_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0xa0c913a9: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'D\xf5u\x07') # 0x44f57507
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\xe2\x81\x9b') # 0x73e2819b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x011\x80\xf0') # 0x13180f0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'\x8e\xd6R\x83') # 0x8ed65283
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select))
data.write(b'{\x08J\xb6') # 0x7b084ab6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x7b084ab6))
data.write(b'fg\xc9\xb1') # 0x6667c9b1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_diddy_sound))
data.write(b'y\xd4P\xb1') # 0x79d450b1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_shield_sound))
data.write(b'<\xf9Gp') # 0x3cf94770
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_heart_sound))
data.write(b'\xa0\xc9\x13\xa9') # 0xa0c913a9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xa0c913a9))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
strg=data['strg'],
title=data['title'],
back=data['back'],
select=data['select'],
caud_0x7b084ab6=data['caud_0x7b084ab6'],
select_diddy_sound=data['select_diddy_sound'],
select_shield_sound=data['select_shield_sound'],
select_heart_sound=data['select_heart_sound'],
caud_0xa0c913a9=data['caud_0xa0c913a9'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'unknown_struct27': self.unknown_struct27.to_json(),
'strg': self.strg,
'title': self.title,
'back': self.back,
'select': self.select,
'caud_0x7b084ab6': self.caud_0x7b084ab6,
'select_diddy_sound': self.select_diddy_sound,
'select_shield_sound': self.select_shield_sound,
'select_heart_sound': self.select_heart_sound,
'caud_0xa0c913a9': self.caud_0xa0c913a9,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_strg(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x7b084ab6(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_diddy_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_shield_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_heart_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0xa0c913a9(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x44f57507: ('unknown_struct29', _decode_unknown_struct29),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0x13180f0: ('strg', _decode_strg),
0xa4f20c17: ('title', _decode_title),
0xe9336455: ('back', _decode_back),
0x8ed65283: ('select', _decode_select),
0x7b084ab6: ('caud_0x7b084ab6', _decode_caud_0x7b084ab6),
0x6667c9b1: ('select_diddy_sound', _decode_select_diddy_sound),
0x79d450b1: ('select_shield_sound', _decode_select_shield_sound),
0x3cf94770: ('select_heart_sound', _decode_select_heart_sound),
0xa0c913a9: ('caud_0xa0c913a9', _decode_caud_0xa0c913a9),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct167.py | 0.524395 | 0.173463 | UnknownStruct167.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct237 import UnknownStruct237
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct238 import UnknownStruct238
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct239 import UnknownStruct239
@dataclasses.dataclass()
class UnknownStruct240(BaseProperty):
mod_should_attack_chance: float = dataclasses.field(default=3.0)
unknown: float = dataclasses.field(default=3.0)
unknown_struct237: UnknownStruct237 = dataclasses.field(default_factory=UnknownStruct237)
unknown_struct238: UnknownStruct238 = dataclasses.field(default_factory=UnknownStruct238)
unknown_struct239: UnknownStruct239 = dataclasses.field(default_factory=UnknownStruct239)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'9\x1fP\xeb') # 0x391f50eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mod_should_attack_chance))
data.write(b'\x88\xe8\xcb\xa1') # 0x88e8cba1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'U\x99\x0e\xd8') # 0x55990ed8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct237.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe5\x91^p') # 0xe5915e70
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct238.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x84\x85^\x0f') # 0x84855e0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct239.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
mod_should_attack_chance=data['mod_should_attack_chance'],
unknown=data['unknown'],
unknown_struct237=UnknownStruct237.from_json(data['unknown_struct237']),
unknown_struct238=UnknownStruct238.from_json(data['unknown_struct238']),
unknown_struct239=UnknownStruct239.from_json(data['unknown_struct239']),
)
def to_json(self) -> dict:
return {
'mod_should_attack_chance': self.mod_should_attack_chance,
'unknown': self.unknown,
'unknown_struct237': self.unknown_struct237.to_json(),
'unknown_struct238': self.unknown_struct238.to_json(),
'unknown_struct239': self.unknown_struct239.to_json(),
}
def _decode_mod_should_attack_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct237(data: typing.BinaryIO, property_size: int):
return UnknownStruct237.from_stream(data, property_size)
def _decode_unknown_struct238(data: typing.BinaryIO, property_size: int):
return UnknownStruct238.from_stream(data, property_size)
def _decode_unknown_struct239(data: typing.BinaryIO, property_size: int):
return UnknownStruct239.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x391f50eb: ('mod_should_attack_chance', _decode_mod_should_attack_chance),
0x88e8cba1: ('unknown', _decode_unknown),
0x55990ed8: ('unknown_struct237', _decode_unknown_struct237),
0xe5915e70: ('unknown_struct238', _decode_unknown_struct238),
0x84855e0f: ('unknown_struct239', _decode_unknown_struct239),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct240.py | 0.642769 | 0.301728 | UnknownStruct240.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class ForestBossStructC(BaseProperty):
scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
scale_locator: str = dataclasses.field(default='')
connector_locator: str = dataclasses.field(default='')
center_locator: str = dataclasses.field(default='')
glowing_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
flee_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_0x749b5d80: str = dataclasses.field(default='')
render_push: float = dataclasses.field(default=1.5)
unknown_0xcb3fd764: float = dataclasses.field(default=1.0)
unknown_0x5b604872: float = dataclasses.field(default=1.0)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\xf7&\xe5\xda') # 0xf726e5da
data.write(b'\x00\x0c') # size
self.scale.to_stream(data)
data.write(b'$Bj\xef') # 0x24426aef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.scale_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\r\x92\r\xe2') # 0xd920de2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.connector_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1[\x9f\xb8') # 0xf15b9fb8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.center_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b]\xfa\xdf') # 0x1b5dfadf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.glowing_texture))
data.write(b"'\x1e.X") # 0x271e2e58
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flee_texture))
data.write(b't\x9b]\x80') # 0x749b5d80
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x749b5d80.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaaq\x962') # 0xaa719632
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push))
data.write(b'\xcb?\xd7d') # 0xcb3fd764
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcb3fd764))
data.write(b'[`Hr') # 0x5b604872
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5b604872))
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
scale=Vector.from_json(data['scale']),
scale_locator=data['scale_locator'],
connector_locator=data['connector_locator'],
center_locator=data['center_locator'],
glowing_texture=data['glowing_texture'],
flee_texture=data['flee_texture'],
unknown_0x749b5d80=data['unknown_0x749b5d80'],
render_push=data['render_push'],
unknown_0xcb3fd764=data['unknown_0xcb3fd764'],
unknown_0x5b604872=data['unknown_0x5b604872'],
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
)
def to_json(self) -> dict:
return {
'scale': self.scale.to_json(),
'scale_locator': self.scale_locator,
'connector_locator': self.connector_locator,
'center_locator': self.center_locator,
'glowing_texture': self.glowing_texture,
'flee_texture': self.flee_texture,
'unknown_0x749b5d80': self.unknown_0x749b5d80,
'render_push': self.render_push,
'unknown_0xcb3fd764': self.unknown_0xcb3fd764,
'unknown_0x5b604872': self.unknown_0x5b604872,
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
}
def _decode_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_scale_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_connector_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_center_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_glowing_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flee_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x749b5d80(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_render_push(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcb3fd764(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5b604872(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf726e5da: ('scale', _decode_scale),
0x24426aef: ('scale_locator', _decode_scale_locator),
0xd920de2: ('connector_locator', _decode_connector_locator),
0xf15b9fb8: ('center_locator', _decode_center_locator),
0x1b5dfadf: ('glowing_texture', _decode_glowing_texture),
0x271e2e58: ('flee_texture', _decode_flee_texture),
0x749b5d80: ('unknown_0x749b5d80', _decode_unknown_0x749b5d80),
0xaa719632: ('render_push', _decode_render_push),
0xcb3fd764: ('unknown_0xcb3fd764', _decode_unknown_0xcb3fd764),
0x5b604872: ('unknown_0x5b604872', _decode_unknown_0x5b604872),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ForestBossStructC.py | 0.569015 | 0.296782 | ForestBossStructC.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.InterpolationMethod import InterpolationMethod
@dataclasses.dataclass()
class FOVInterpolationMethod(BaseProperty):
fov_type: enums.FOVType = dataclasses.field(default=enums.FOVType.Unknown2)
fov_control: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x19\xea\x15\x1b') # 0x19ea151b
data.write(b'\x00\x04') # size
self.fov_type.to_stream(data)
data.write(b'\x9f\x90\x01L') # 0x9f90014c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
fov_type=enums.FOVType.from_json(data['fov_type']),
fov_control=InterpolationMethod.from_json(data['fov_control']),
)
def to_json(self) -> dict:
return {
'fov_type': self.fov_type.to_json(),
'fov_control': self.fov_control.to_json(),
}
def _decode_fov_type(data: typing.BinaryIO, property_size: int):
return enums.FOVType.from_stream(data)
def _decode_fov_control(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x19ea151b: ('fov_type', _decode_fov_type),
0x9f90014c: ('fov_control', _decode_fov_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FOVInterpolationMethod.py | 0.579995 | 0.301079 | FOVInterpolationMethod.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ModifyContactRuleData(BaseProperty):
number_of_alternate_rules: int = dataclasses.field(default=0)
contact_rules_alternate1: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
contact_rules_alternate2: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
contact_rules_alternate3: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
contact_rules_alternate4: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
contact_rules_alternate5: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xef\xa6\xfcu') # 0xefa6fc75
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_alternate_rules))
data.write(b'y\x92\xd8\xa1') # 0x7992d8a1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rules_alternate1))
data.write(b'\xff\x06\xaa\x0f') # 0xff06aa0f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rules_alternate2))
data.write(b'4Zy\xaa') # 0x345a79aa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rules_alternate3))
data.write(b')_I\x12') # 0x295f4912
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rules_alternate4))
data.write(b'\xe2\x03\x9a\xb7') # 0xe2039ab7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rules_alternate5))
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_alternate_rules=data['number_of_alternate_rules'],
contact_rules_alternate1=data['contact_rules_alternate1'],
contact_rules_alternate2=data['contact_rules_alternate2'],
contact_rules_alternate3=data['contact_rules_alternate3'],
contact_rules_alternate4=data['contact_rules_alternate4'],
contact_rules_alternate5=data['contact_rules_alternate5'],
)
def to_json(self) -> dict:
return {
'number_of_alternate_rules': self.number_of_alternate_rules,
'contact_rules_alternate1': self.contact_rules_alternate1,
'contact_rules_alternate2': self.contact_rules_alternate2,
'contact_rules_alternate3': self.contact_rules_alternate3,
'contact_rules_alternate4': self.contact_rules_alternate4,
'contact_rules_alternate5': self.contact_rules_alternate5,
}
_FAST_FORMAT = None
_FAST_IDS = (0xefa6fc75, 0x7992d8a1, 0xff06aa0f, 0x345a79aa, 0x295f4912, 0xe2039ab7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ModifyContactRuleData]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(80))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return ModifyContactRuleData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_number_of_alternate_rules(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_contact_rules_alternate1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_contact_rules_alternate2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_contact_rules_alternate3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_contact_rules_alternate4(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_contact_rules_alternate5(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xefa6fc75: ('number_of_alternate_rules', _decode_number_of_alternate_rules),
0x7992d8a1: ('contact_rules_alternate1', _decode_contact_rules_alternate1),
0xff06aa0f: ('contact_rules_alternate2', _decode_contact_rules_alternate2),
0x345a79aa: ('contact_rules_alternate3', _decode_contact_rules_alternate3),
0x295f4912: ('contact_rules_alternate4', _decode_contact_rules_alternate4),
0xe2039ab7: ('contact_rules_alternate5', _decode_contact_rules_alternate5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ModifyContactRuleData.py | 0.58948 | 0.213029 | ModifyContactRuleData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct145(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
how_to: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
move_left: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
move_right: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
run_grab: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
jump: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
pause: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
crouch: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
ground_pound: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
blow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
mount: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
dismount: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
roll: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
blow_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
mount_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
dismount_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
roll_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x16') # 22 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'^\xe2\xdbK') # 0x5ee2db4b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.how_to))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'm@)\xd0') # 0x6d4029d0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.move_left))
data.write(b'`\x188\xab') # 0x601838ab
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.move_right))
data.write(b'\xec\xc7\x8b\x13') # 0xecc78b13
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.run_grab))
data.write(b'\x934p\x99') # 0x93347099
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.jump))
data.write(b'K\xfd\xe2\xcc') # 0x4bfde2cc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.pause))
data.write(b'\xd4p\xc3\xd7') # 0xd470c3d7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crouch))
data.write(b'`\xfa\xff\x80') # 0x60faff80
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ground_pound))
data.write(b'\xc1\x82\xd9\x10') # 0xc182d910
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.blow))
data.write(b'\x9f\xec\x1f6') # 0x9fec1f36
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.mount))
data.write(b'\x93@\xabD') # 0x9340ab44
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dismount))
data.write(b'\xbb4tG') # 0xbb347447
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll))
data.write(b"'5\x98\x1e") # 0x2735981e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.blow_input))
data.write(b'\x9e\x94\xfb\xac') # 0x9e94fbac
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'\\\xe3e\x90') # 0x5ce36590
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.mount_input))
data.write(b'16\xe4\xfa') # 0x3136e4fa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dismount_input))
data.write(b'\x06\x04Y\xc3') # 0x60459c3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll_input))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title=data['title'],
how_to=data['how_to'],
back=data['back'],
back_core=data['back_core'],
move_left=data['move_left'],
move_right=data['move_right'],
run_grab=data['run_grab'],
jump=data['jump'],
pause=data['pause'],
crouch=data['crouch'],
ground_pound=data['ground_pound'],
blow=data['blow'],
mount=data['mount'],
dismount=data['dismount'],
roll=data['roll'],
blow_input=data['blow_input'],
strg=data['strg'],
mount_input=data['mount_input'],
dismount_input=data['dismount_input'],
roll_input=data['roll_input'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title': self.title,
'how_to': self.how_to,
'back': self.back,
'back_core': self.back_core,
'move_left': self.move_left,
'move_right': self.move_right,
'run_grab': self.run_grab,
'jump': self.jump,
'pause': self.pause,
'crouch': self.crouch,
'ground_pound': self.ground_pound,
'blow': self.blow,
'mount': self.mount,
'dismount': self.dismount,
'roll': self.roll,
'blow_input': self.blow_input,
'strg': self.strg,
'mount_input': self.mount_input,
'dismount_input': self.dismount_input,
'roll_input': self.roll_input,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_how_to(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_move_left(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_move_right(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_run_grab(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_jump(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_pause(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_crouch(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ground_pound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_blow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_mount(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dismount(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_roll(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_blow_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_mount_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dismount_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_roll_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0xa4f20c17: ('title', _decode_title),
0x5ee2db4b: ('how_to', _decode_how_to),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x6d4029d0: ('move_left', _decode_move_left),
0x601838ab: ('move_right', _decode_move_right),
0xecc78b13: ('run_grab', _decode_run_grab),
0x93347099: ('jump', _decode_jump),
0x4bfde2cc: ('pause', _decode_pause),
0xd470c3d7: ('crouch', _decode_crouch),
0x60faff80: ('ground_pound', _decode_ground_pound),
0xc182d910: ('blow', _decode_blow),
0x9fec1f36: ('mount', _decode_mount),
0x9340ab44: ('dismount', _decode_dismount),
0xbb347447: ('roll', _decode_roll),
0x2735981e: ('blow_input', _decode_blow_input),
0x9e94fbac: ('strg', _decode_strg),
0x5ce36590: ('mount_input', _decode_mount_input),
0x3136e4fa: ('dismount_input', _decode_dismount_input),
0x60459c3: ('roll_input', _decode_roll_input),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct145.py | 0.546496 | 0.168754 | UnknownStruct145.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct144(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
how_to: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
movement: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
grab: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
jump: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
pause: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
crouch: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
ground_pound: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
blow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
roll: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
mount: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
dismount: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
blow_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
crouch_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
roll_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
mount_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
dismount_input: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x16') # 22 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'^\xe2\xdbK') # 0x5ee2db4b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.how_to))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'\xcb%\xf1W') # 0xcb25f157
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.movement))
data.write(b'\xe1\x00W3') # 0xe1005733
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.grab))
data.write(b'\x934p\x99') # 0x93347099
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.jump))
data.write(b'K\xfd\xe2\xcc') # 0x4bfde2cc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.pause))
data.write(b'\xd4p\xc3\xd7') # 0xd470c3d7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crouch))
data.write(b'`\xfa\xff\x80') # 0x60faff80
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ground_pound))
data.write(b'\xc1\x82\xd9\x10') # 0xc182d910
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.blow))
data.write(b'\xbb4tG') # 0xbb347447
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll))
data.write(b'\x9f\xec\x1f6') # 0x9fec1f36
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.mount))
data.write(b'\x93@\xabD') # 0x9340ab44
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dismount))
data.write(b"'5\x98\x1e") # 0x2735981e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.blow_input))
data.write(b'\x9e\x94\xfb\xac') # 0x9e94fbac
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'\xc2QZ\x84') # 0xc2515a84
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crouch_input))
data.write(b'\x06\x04Y\xc3') # 0x60459c3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll_input))
data.write(b'\\\xe3e\x90') # 0x5ce36590
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.mount_input))
data.write(b'16\xe4\xfa') # 0x3136e4fa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dismount_input))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title=data['title'],
how_to=data['how_to'],
back=data['back'],
back_core=data['back_core'],
movement=data['movement'],
grab=data['grab'],
jump=data['jump'],
pause=data['pause'],
crouch=data['crouch'],
ground_pound=data['ground_pound'],
blow=data['blow'],
roll=data['roll'],
mount=data['mount'],
dismount=data['dismount'],
blow_input=data['blow_input'],
strg=data['strg'],
crouch_input=data['crouch_input'],
roll_input=data['roll_input'],
mount_input=data['mount_input'],
dismount_input=data['dismount_input'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title': self.title,
'how_to': self.how_to,
'back': self.back,
'back_core': self.back_core,
'movement': self.movement,
'grab': self.grab,
'jump': self.jump,
'pause': self.pause,
'crouch': self.crouch,
'ground_pound': self.ground_pound,
'blow': self.blow,
'roll': self.roll,
'mount': self.mount,
'dismount': self.dismount,
'blow_input': self.blow_input,
'strg': self.strg,
'crouch_input': self.crouch_input,
'roll_input': self.roll_input,
'mount_input': self.mount_input,
'dismount_input': self.dismount_input,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_how_to(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_movement(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_grab(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_jump(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_pause(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_crouch(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ground_pound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_blow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_roll(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_mount(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dismount(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_blow_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_crouch_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_roll_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_mount_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dismount_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0xa4f20c17: ('title', _decode_title),
0x5ee2db4b: ('how_to', _decode_how_to),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0xcb25f157: ('movement', _decode_movement),
0xe1005733: ('grab', _decode_grab),
0x93347099: ('jump', _decode_jump),
0x4bfde2cc: ('pause', _decode_pause),
0xd470c3d7: ('crouch', _decode_crouch),
0x60faff80: ('ground_pound', _decode_ground_pound),
0xc182d910: ('blow', _decode_blow),
0xbb347447: ('roll', _decode_roll),
0x9fec1f36: ('mount', _decode_mount),
0x9340ab44: ('dismount', _decode_dismount),
0x2735981e: ('blow_input', _decode_blow_input),
0x9e94fbac: ('strg', _decode_strg),
0xc2515a84: ('crouch_input', _decode_crouch_input),
0x60459c3: ('roll_input', _decode_roll_input),
0x5ce36590: ('mount_input', _decode_mount_input),
0x3136e4fa: ('dismount_input', _decode_dismount_input),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct144.py | 0.541894 | 0.160398 | UnknownStruct144.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerPeanutGunData(BaseProperty):
is_peanut_gun_owner: bool = dataclasses.field(default=False)
fire_height_offset: float = dataclasses.field(default=0.75)
can_fire_when_mounted_to_dk: bool = dataclasses.field(default=True)
can_fire_when_mounted_to_rambi: bool = dataclasses.field(default=True)
can_fire_when_mounted_to_dk_on_rambi: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\x0e\x0f m') # 0xe0f206d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_peanut_gun_owner))
data.write(b'\xe0/\xad\xa2') # 0xe02fada2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fire_height_offset))
data.write(b'Ut\xa8\xed') # 0x5574a8ed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_fire_when_mounted_to_dk))
data.write(b'\xe7C\xb2\xa5') # 0xe743b2a5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_fire_when_mounted_to_rambi))
data.write(b'\xce\xb2\t\xb7') # 0xceb209b7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_fire_when_mounted_to_dk_on_rambi))
@classmethod
def from_json(cls, data: dict):
return cls(
is_peanut_gun_owner=data['is_peanut_gun_owner'],
fire_height_offset=data['fire_height_offset'],
can_fire_when_mounted_to_dk=data['can_fire_when_mounted_to_dk'],
can_fire_when_mounted_to_rambi=data['can_fire_when_mounted_to_rambi'],
can_fire_when_mounted_to_dk_on_rambi=data['can_fire_when_mounted_to_dk_on_rambi'],
)
def to_json(self) -> dict:
return {
'is_peanut_gun_owner': self.is_peanut_gun_owner,
'fire_height_offset': self.fire_height_offset,
'can_fire_when_mounted_to_dk': self.can_fire_when_mounted_to_dk,
'can_fire_when_mounted_to_rambi': self.can_fire_when_mounted_to_rambi,
'can_fire_when_mounted_to_dk_on_rambi': self.can_fire_when_mounted_to_dk_on_rambi,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe0f206d, 0xe02fada2, 0x5574a8ed, 0xe743b2a5, 0xceb209b7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerPeanutGunData]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(38))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return PlayerPeanutGunData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_is_peanut_gun_owner(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fire_height_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_can_fire_when_mounted_to_dk(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_fire_when_mounted_to_rambi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_fire_when_mounted_to_dk_on_rambi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe0f206d: ('is_peanut_gun_owner', _decode_is_peanut_gun_owner),
0xe02fada2: ('fire_height_offset', _decode_fire_height_offset),
0x5574a8ed: ('can_fire_when_mounted_to_dk', _decode_can_fire_when_mounted_to_dk),
0xe743b2a5: ('can_fire_when_mounted_to_rambi', _decode_can_fire_when_mounted_to_rambi),
0xceb209b7: ('can_fire_when_mounted_to_dk_on_rambi', _decode_can_fire_when_mounted_to_dk_on_rambi),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerPeanutGunData.py | 0.595375 | 0.323207 | PlayerPeanutGunData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct135(BaseProperty):
death_fling: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown: str = dataclasses.field(default='')
blow_left: str = dataclasses.field(default='')
blow_right: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x92I\xd6\xb3') # 0x9249d6b3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_fling))
data.write(b'\xb2b\x83\xce') # 0xb26283ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xa8\x0f\x03') # 0x24a80f03
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.blow_left.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94_\xb4\xee') # 0x945fb4ee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.blow_right.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
death_fling=data['death_fling'],
unknown=data['unknown'],
blow_left=data['blow_left'],
blow_right=data['blow_right'],
)
def to_json(self) -> dict:
return {
'death_fling': self.death_fling,
'unknown': self.unknown,
'blow_left': self.blow_left,
'blow_right': self.blow_right,
}
def _decode_death_fling(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_blow_left(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_blow_right(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9249d6b3: ('death_fling', _decode_death_fling),
0xb26283ce: ('unknown', _decode_unknown),
0x24a80f03: ('blow_left', _decode_blow_left),
0x945fb4ee: ('blow_right', _decode_blow_right),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct135.py | 0.621771 | 0.285337 | UnknownStruct135.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct15 import UnknownStruct15
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct68 import UnknownStruct68
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct71 import UnknownStruct71
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct72 import UnknownStruct72
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct73(BaseProperty):
camera_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=26.0, y=0.0, z=0.0))
unknown_struct68: UnknownStruct68 = dataclasses.field(default_factory=UnknownStruct68)
adjust_vertical_based_on_pullback: bool = dataclasses.field(default=False)
unknown: bool = dataclasses.field(default=False)
unknown_struct71: UnknownStruct71 = dataclasses.field(default_factory=UnknownStruct71)
unknown_struct15: UnknownStruct15 = dataclasses.field(default_factory=UnknownStruct15)
unknown_struct72: UnknownStruct72 = dataclasses.field(default_factory=UnknownStruct72)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'g\x17\x08\x8c') # 0x6717088c
data.write(b'\x00\x0c') # size
self.camera_offset.to_stream(data)
data.write(b'\xd5,\xd4\xfb') # 0xd52cd4fb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct68.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94z\xa9U') # 0x947aa955
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.adjust_vertical_based_on_pullback))
data.write(b'\x81x\xa6\x0f') # 0x8178a60f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b"'\x01w\x1f") # 0x2701771f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct71.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\xc3\x17\x85') # 0xc0c31785
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct15.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-c\xb0\xf7') # 0x2d63b0f7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct72.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
camera_offset=Vector.from_json(data['camera_offset']),
unknown_struct68=UnknownStruct68.from_json(data['unknown_struct68']),
adjust_vertical_based_on_pullback=data['adjust_vertical_based_on_pullback'],
unknown=data['unknown'],
unknown_struct71=UnknownStruct71.from_json(data['unknown_struct71']),
unknown_struct15=UnknownStruct15.from_json(data['unknown_struct15']),
unknown_struct72=UnknownStruct72.from_json(data['unknown_struct72']),
)
def to_json(self) -> dict:
return {
'camera_offset': self.camera_offset.to_json(),
'unknown_struct68': self.unknown_struct68.to_json(),
'adjust_vertical_based_on_pullback': self.adjust_vertical_based_on_pullback,
'unknown': self.unknown,
'unknown_struct71': self.unknown_struct71.to_json(),
'unknown_struct15': self.unknown_struct15.to_json(),
'unknown_struct72': self.unknown_struct72.to_json(),
}
def _decode_camera_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_struct68(data: typing.BinaryIO, property_size: int):
return UnknownStruct68.from_stream(data, property_size)
def _decode_adjust_vertical_based_on_pullback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct71(data: typing.BinaryIO, property_size: int):
return UnknownStruct71.from_stream(data, property_size)
def _decode_unknown_struct15(data: typing.BinaryIO, property_size: int):
return UnknownStruct15.from_stream(data, property_size)
def _decode_unknown_struct72(data: typing.BinaryIO, property_size: int):
return UnknownStruct72.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6717088c: ('camera_offset', _decode_camera_offset),
0xd52cd4fb: ('unknown_struct68', _decode_unknown_struct68),
0x947aa955: ('adjust_vertical_based_on_pullback', _decode_adjust_vertical_based_on_pullback),
0x8178a60f: ('unknown', _decode_unknown),
0x2701771f: ('unknown_struct71', _decode_unknown_struct71),
0xc0c31785: ('unknown_struct15', _decode_unknown_struct15),
0x2d63b0f7: ('unknown_struct72', _decode_unknown_struct72),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct73.py | 0.657428 | 0.289271 | UnknownStruct73.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class SkinSwapModifierData(BaseProperty):
skin: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x93\x12\xfa\xb8') # 0x9312fab8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.skin.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
skin=AnimationParameters.from_json(data['skin']),
)
def to_json(self) -> dict:
return {
'skin': self.skin.to_json(),
}
def _decode_skin(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9312fab8: ('skin', _decode_skin),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SkinSwapModifierData.py | 0.682574 | 0.271855 | SkinSwapModifierData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class TriggerInfo(BaseProperty):
unknown_0x97c0611f: int = dataclasses.field(default=1)
unknown_0x50224907: int = dataclasses.field(default=128)
unknown_0x7150d7f8: bool = dataclasses.field(default=False)
unknown_0x46cc1b48: bool = dataclasses.field(default=False)
damage_spline: Spline = dataclasses.field(default_factory=Spline)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
force_field: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
max_target_speed: float = dataclasses.field(default=1.0)
near_visible_range: float = dataclasses.field(default=10.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x97\xc0a\x1f') # 0x97c0611f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x97c0611f))
data.write(b'P"I\x07') # 0x50224907
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x50224907))
data.write(b'qP\xd7\xf8') # 0x7150d7f8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7150d7f8))
data.write(b'F\xcc\x1bH') # 0x46cc1b48
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x46cc1b48))
data.write(b'\xfa\x87:g') # 0xfa873a67
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' \x92~\x9b') # 0x20927e9b
data.write(b'\x00\x0c') # size
self.force_field.to_stream(data)
data.write(b'\xcb(\xe9s') # 0xcb28e973
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_target_speed))
data.write(b'\x99y\xf6\x0b') # 0x9979f60b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.near_visible_range))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x97c0611f=data['unknown_0x97c0611f'],
unknown_0x50224907=data['unknown_0x50224907'],
unknown_0x7150d7f8=data['unknown_0x7150d7f8'],
unknown_0x46cc1b48=data['unknown_0x46cc1b48'],
damage_spline=Spline.from_json(data['damage_spline']),
damage=DamageInfo.from_json(data['damage']),
force_field=Vector.from_json(data['force_field']),
max_target_speed=data['max_target_speed'],
near_visible_range=data['near_visible_range'],
)
def to_json(self) -> dict:
return {
'unknown_0x97c0611f': self.unknown_0x97c0611f,
'unknown_0x50224907': self.unknown_0x50224907,
'unknown_0x7150d7f8': self.unknown_0x7150d7f8,
'unknown_0x46cc1b48': self.unknown_0x46cc1b48,
'damage_spline': self.damage_spline.to_json(),
'damage': self.damage.to_json(),
'force_field': self.force_field.to_json(),
'max_target_speed': self.max_target_speed,
'near_visible_range': self.near_visible_range,
}
def _decode_unknown_0x97c0611f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x50224907(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7150d7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x46cc1b48(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damage_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_force_field(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_max_target_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_near_visible_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x97c0611f: ('unknown_0x97c0611f', _decode_unknown_0x97c0611f),
0x50224907: ('unknown_0x50224907', _decode_unknown_0x50224907),
0x7150d7f8: ('unknown_0x7150d7f8', _decode_unknown_0x7150d7f8),
0x46cc1b48: ('unknown_0x46cc1b48', _decode_unknown_0x46cc1b48),
0xfa873a67: ('damage_spline', _decode_damage_spline),
0x337f9524: ('damage', _decode_damage),
0x20927e9b: ('force_field', _decode_force_field),
0xcb28e973: ('max_target_speed', _decode_max_target_speed),
0x9979f60b: ('near_visible_range', _decode_near_visible_range),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TriggerInfo.py | 0.635562 | 0.254127 | TriggerInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct268(BaseProperty):
spinner_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
spline_input: enums.SplineInput = dataclasses.field(default=enums.SplineInput.Unknown1)
sound_ratio_change_factor: float = dataclasses.field(default=0.5)
sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
sound_pitch: Spline = dataclasses.field(default_factory=Spline)
sound_volume: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xd8s\x8f\xc8') # 0xd8738fc8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.spinner_sound))
data.write(b'j\x06\xfa\xee') # 0x6a06faee
data.write(b'\x00\x04') # size
self.spline_input.to_stream(data)
data.write(b'\n\xc5o\xc9') # 0xac56fc9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.sound_ratio_change_factor))
data.write(b'\xf2|\x01\xee') # 0xf27c01ee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcf\xe4#$') # 0xcfe42324
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S0\x90\xa0') # 0x533090a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
spinner_sound=data['spinner_sound'],
spline_input=enums.SplineInput.from_json(data['spline_input']),
sound_ratio_change_factor=data['sound_ratio_change_factor'],
sound_low_pass_filter=Spline.from_json(data['sound_low_pass_filter']),
sound_pitch=Spline.from_json(data['sound_pitch']),
sound_volume=Spline.from_json(data['sound_volume']),
)
def to_json(self) -> dict:
return {
'spinner_sound': self.spinner_sound,
'spline_input': self.spline_input.to_json(),
'sound_ratio_change_factor': self.sound_ratio_change_factor,
'sound_low_pass_filter': self.sound_low_pass_filter.to_json(),
'sound_pitch': self.sound_pitch.to_json(),
'sound_volume': self.sound_volume.to_json(),
}
def _decode_spinner_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_spline_input(data: typing.BinaryIO, property_size: int):
return enums.SplineInput.from_stream(data)
def _decode_sound_ratio_change_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd8738fc8: ('spinner_sound', _decode_spinner_sound),
0x6a06faee: ('spline_input', _decode_spline_input),
0xac56fc9: ('sound_ratio_change_factor', _decode_sound_ratio_change_factor),
0xf27c01ee: ('sound_low_pass_filter', _decode_sound_low_pass_filter),
0xcfe42324: ('sound_pitch', _decode_sound_pitch),
0x533090a0: ('sound_volume', _decode_sound_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct268.py | 0.599954 | 0.225886 | UnknownStruct268.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class SwingRopeData(BaseProperty):
unknown_0x7e20a7c9: float = dataclasses.field(default=0.05000000074505806)
rope_blend_mode: enums.RopeBlendMode = dataclasses.field(default=enums.RopeBlendMode.Unknown1)
no_grab_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
end_cap_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
max_angle: float = dataclasses.field(default=45.0)
minimum_swing_radius: float = dataclasses.field(default=2.0)
unknown_0xbf43e511: float = dataclasses.field(default=0.5)
is_rigid: bool = dataclasses.field(default=False)
unknown_0x5b5f1a7d: bool = dataclasses.field(default=False)
unknown_0x2c02f3ca: bool = dataclasses.field(default=False)
unknown_0x8388e38b: float = dataclasses.field(default=0.0)
auto_start_auto_swing: bool = dataclasses.field(default=True)
unknown_0x77c8cc96: Spline = dataclasses.field(default_factory=Spline)
unknown_0x723a15a5: float = dataclasses.field(default=0.25)
unknown_0xbecb0936: float = dataclasses.field(default=0.5)
unknown_0x84594ed5: bool = dataclasses.field(default=False)
unknown_0x941efaa0: bool = dataclasses.field(default=False)
unknown_0x36f40c13: int = dataclasses.field(default=0)
unknown_0x1acb67f5: int = dataclasses.field(default=24)
unknown_0x087ec81b: int = dataclasses.field(default=24)
unknown_0xb0c2af7e: int = dataclasses.field(default=24)
unknown_0x2d1597c7: int = dataclasses.field(default=24)
unknown_0x95a9f0a2: int = dataclasses.field(default=24)
unknown_0x871c5f4c: int = dataclasses.field(default=24)
unknown_0x3fa03829: int = dataclasses.field(default=24)
unknown_0x67c3287f: int = dataclasses.field(default=24)
unknown_0xdf7f4f1a: int = dataclasses.field(default=24)
unknown_0x99c2d4a7: int = dataclasses.field(default=24)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1d') # 29 properties
data.write(b'~ \xa7\xc9') # 0x7e20a7c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7e20a7c9))
data.write(b',2G-') # 0x2c32472d
data.write(b'\x00\x04') # size
self.rope_blend_mode.to_stream(data)
data.write(b'\xd9\xdf3\x9a') # 0xd9df339a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.no_grab_texture))
data.write(b'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture))
data.write(b'<^-\x90') # 0x3c5e2d90
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.end_cap_texture))
data.write(b'\xd9cU\x83') # 0xd9635583
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_angle))
data.write(b'\x92\xac\x886') # 0x92ac8836
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_swing_radius))
data.write(b'\xbfC\xe5\x11') # 0xbf43e511
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbf43e511))
data.write(b'\xce\x9e\x91x') # 0xce9e9178
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_rigid))
data.write(b'[_\x1a}') # 0x5b5f1a7d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5b5f1a7d))
data.write(b',\x02\xf3\xca') # 0x2c02f3ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2c02f3ca))
data.write(b'\x83\x88\xe3\x8b') # 0x8388e38b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8388e38b))
data.write(b'\t\xee\x1b\x0b') # 0x9ee1b0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start_auto_swing))
data.write(b'w\xc8\xcc\x96') # 0x77c8cc96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x77c8cc96.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'r:\x15\xa5') # 0x723a15a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x723a15a5))
data.write(b'\xbe\xcb\t6') # 0xbecb0936
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbecb0936))
data.write(b'\x84YN\xd5') # 0x84594ed5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x84594ed5))
data.write(b'\x94\x1e\xfa\xa0') # 0x941efaa0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x941efaa0))
data.write(b'6\xf4\x0c\x13') # 0x36f40c13
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x36f40c13))
data.write(b'\x1a\xcbg\xf5') # 0x1acb67f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x1acb67f5))
data.write(b'\x08~\xc8\x1b') # 0x87ec81b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x087ec81b))
data.write(b'\xb0\xc2\xaf~') # 0xb0c2af7e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xb0c2af7e))
data.write(b'-\x15\x97\xc7') # 0x2d1597c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2d1597c7))
data.write(b'\x95\xa9\xf0\xa2') # 0x95a9f0a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x95a9f0a2))
data.write(b'\x87\x1c_L') # 0x871c5f4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x871c5f4c))
data.write(b'?\xa08)') # 0x3fa03829
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3fa03829))
data.write(b'g\xc3(\x7f') # 0x67c3287f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x67c3287f))
data.write(b'\xdf\x7fO\x1a') # 0xdf7f4f1a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xdf7f4f1a))
data.write(b'\x99\xc2\xd4\xa7') # 0x99c2d4a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x99c2d4a7))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x7e20a7c9=data['unknown_0x7e20a7c9'],
rope_blend_mode=enums.RopeBlendMode.from_json(data['rope_blend_mode']),
no_grab_texture=data['no_grab_texture'],
texture=data['texture'],
end_cap_texture=data['end_cap_texture'],
max_angle=data['max_angle'],
minimum_swing_radius=data['minimum_swing_radius'],
unknown_0xbf43e511=data['unknown_0xbf43e511'],
is_rigid=data['is_rigid'],
unknown_0x5b5f1a7d=data['unknown_0x5b5f1a7d'],
unknown_0x2c02f3ca=data['unknown_0x2c02f3ca'],
unknown_0x8388e38b=data['unknown_0x8388e38b'],
auto_start_auto_swing=data['auto_start_auto_swing'],
unknown_0x77c8cc96=Spline.from_json(data['unknown_0x77c8cc96']),
unknown_0x723a15a5=data['unknown_0x723a15a5'],
unknown_0xbecb0936=data['unknown_0xbecb0936'],
unknown_0x84594ed5=data['unknown_0x84594ed5'],
unknown_0x941efaa0=data['unknown_0x941efaa0'],
unknown_0x36f40c13=data['unknown_0x36f40c13'],
unknown_0x1acb67f5=data['unknown_0x1acb67f5'],
unknown_0x087ec81b=data['unknown_0x087ec81b'],
unknown_0xb0c2af7e=data['unknown_0xb0c2af7e'],
unknown_0x2d1597c7=data['unknown_0x2d1597c7'],
unknown_0x95a9f0a2=data['unknown_0x95a9f0a2'],
unknown_0x871c5f4c=data['unknown_0x871c5f4c'],
unknown_0x3fa03829=data['unknown_0x3fa03829'],
unknown_0x67c3287f=data['unknown_0x67c3287f'],
unknown_0xdf7f4f1a=data['unknown_0xdf7f4f1a'],
unknown_0x99c2d4a7=data['unknown_0x99c2d4a7'],
)
def to_json(self) -> dict:
return {
'unknown_0x7e20a7c9': self.unknown_0x7e20a7c9,
'rope_blend_mode': self.rope_blend_mode.to_json(),
'no_grab_texture': self.no_grab_texture,
'texture': self.texture,
'end_cap_texture': self.end_cap_texture,
'max_angle': self.max_angle,
'minimum_swing_radius': self.minimum_swing_radius,
'unknown_0xbf43e511': self.unknown_0xbf43e511,
'is_rigid': self.is_rigid,
'unknown_0x5b5f1a7d': self.unknown_0x5b5f1a7d,
'unknown_0x2c02f3ca': self.unknown_0x2c02f3ca,
'unknown_0x8388e38b': self.unknown_0x8388e38b,
'auto_start_auto_swing': self.auto_start_auto_swing,
'unknown_0x77c8cc96': self.unknown_0x77c8cc96.to_json(),
'unknown_0x723a15a5': self.unknown_0x723a15a5,
'unknown_0xbecb0936': self.unknown_0xbecb0936,
'unknown_0x84594ed5': self.unknown_0x84594ed5,
'unknown_0x941efaa0': self.unknown_0x941efaa0,
'unknown_0x36f40c13': self.unknown_0x36f40c13,
'unknown_0x1acb67f5': self.unknown_0x1acb67f5,
'unknown_0x087ec81b': self.unknown_0x087ec81b,
'unknown_0xb0c2af7e': self.unknown_0xb0c2af7e,
'unknown_0x2d1597c7': self.unknown_0x2d1597c7,
'unknown_0x95a9f0a2': self.unknown_0x95a9f0a2,
'unknown_0x871c5f4c': self.unknown_0x871c5f4c,
'unknown_0x3fa03829': self.unknown_0x3fa03829,
'unknown_0x67c3287f': self.unknown_0x67c3287f,
'unknown_0xdf7f4f1a': self.unknown_0xdf7f4f1a,
'unknown_0x99c2d4a7': self.unknown_0x99c2d4a7,
}
def _decode_unknown_0x7e20a7c9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rope_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.RopeBlendMode.from_stream(data)
def _decode_no_grab_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_end_cap_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_max_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_swing_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbf43e511(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_rigid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x5b5f1a7d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2c02f3ca(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x8388e38b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_start_auto_swing(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x77c8cc96(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x723a15a5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbecb0936(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x84594ed5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x941efaa0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x36f40c13(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x1acb67f5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x087ec81b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xb0c2af7e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2d1597c7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x95a9f0a2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x871c5f4c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x3fa03829(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x67c3287f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xdf7f4f1a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x99c2d4a7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7e20a7c9: ('unknown_0x7e20a7c9', _decode_unknown_0x7e20a7c9),
0x2c32472d: ('rope_blend_mode', _decode_rope_blend_mode),
0xd9df339a: ('no_grab_texture', _decode_no_grab_texture),
0xd1f65872: ('texture', _decode_texture),
0x3c5e2d90: ('end_cap_texture', _decode_end_cap_texture),
0xd9635583: ('max_angle', _decode_max_angle),
0x92ac8836: ('minimum_swing_radius', _decode_minimum_swing_radius),
0xbf43e511: ('unknown_0xbf43e511', _decode_unknown_0xbf43e511),
0xce9e9178: ('is_rigid', _decode_is_rigid),
0x5b5f1a7d: ('unknown_0x5b5f1a7d', _decode_unknown_0x5b5f1a7d),
0x2c02f3ca: ('unknown_0x2c02f3ca', _decode_unknown_0x2c02f3ca),
0x8388e38b: ('unknown_0x8388e38b', _decode_unknown_0x8388e38b),
0x9ee1b0b: ('auto_start_auto_swing', _decode_auto_start_auto_swing),
0x77c8cc96: ('unknown_0x77c8cc96', _decode_unknown_0x77c8cc96),
0x723a15a5: ('unknown_0x723a15a5', _decode_unknown_0x723a15a5),
0xbecb0936: ('unknown_0xbecb0936', _decode_unknown_0xbecb0936),
0x84594ed5: ('unknown_0x84594ed5', _decode_unknown_0x84594ed5),
0x941efaa0: ('unknown_0x941efaa0', _decode_unknown_0x941efaa0),
0x36f40c13: ('unknown_0x36f40c13', _decode_unknown_0x36f40c13),
0x1acb67f5: ('unknown_0x1acb67f5', _decode_unknown_0x1acb67f5),
0x87ec81b: ('unknown_0x087ec81b', _decode_unknown_0x087ec81b),
0xb0c2af7e: ('unknown_0xb0c2af7e', _decode_unknown_0xb0c2af7e),
0x2d1597c7: ('unknown_0x2d1597c7', _decode_unknown_0x2d1597c7),
0x95a9f0a2: ('unknown_0x95a9f0a2', _decode_unknown_0x95a9f0a2),
0x871c5f4c: ('unknown_0x871c5f4c', _decode_unknown_0x871c5f4c),
0x3fa03829: ('unknown_0x3fa03829', _decode_unknown_0x3fa03829),
0x67c3287f: ('unknown_0x67c3287f', _decode_unknown_0x67c3287f),
0xdf7f4f1a: ('unknown_0xdf7f4f1a', _decode_unknown_0xdf7f4f1a),
0x99c2d4a7: ('unknown_0x99c2d4a7', _decode_unknown_0x99c2d4a7),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SwingRopeData.py | 0.614163 | 0.229406 | SwingRopeData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct26(BaseProperty):
text_gradient_start_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.9960780143737793, g=0.9764710068702698, b=0.6078429818153381, a=0.0))
text_gradient_end_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.9568629860877991, g=0.7882350087165833, b=0.32548999786376953, a=0.0))
text_outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.764706015586853, g=0.04705899953842163, b=0.031373001635074615, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xf9\xe0\xd0\xfb') # 0xf9e0d0fb
data.write(b'\x00\x10') # size
self.text_gradient_start_color.to_stream(data)
data.write(b'\xe0A~\x89') # 0xe0417e89
data.write(b'\x00\x10') # size
self.text_gradient_end_color.to_stream(data)
data.write(b'\xf2\xe15\x06') # 0xf2e13506
data.write(b'\x00\x10') # size
self.text_outline_color.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
text_gradient_start_color=Color.from_json(data['text_gradient_start_color']),
text_gradient_end_color=Color.from_json(data['text_gradient_end_color']),
text_outline_color=Color.from_json(data['text_outline_color']),
)
def to_json(self) -> dict:
return {
'text_gradient_start_color': self.text_gradient_start_color.to_json(),
'text_gradient_end_color': self.text_gradient_end_color.to_json(),
'text_outline_color': self.text_outline_color.to_json(),
}
def _decode_text_gradient_start_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_gradient_end_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf9e0d0fb: ('text_gradient_start_color', _decode_text_gradient_start_color),
0xe0417e89: ('text_gradient_end_color', _decode_text_gradient_end_color),
0xf2e13506: ('text_outline_color', _decode_text_outline_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct26.py | 0.731538 | 0.246885 | UnknownStruct26.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct26 import UnknownStruct26
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct28(BaseProperty):
hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
appear_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
no_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
yes_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
animated_appear: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x0c9c9c3b: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x6a6aa42e: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
animated_disappear: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
no: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
no_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
yes: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
yes_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
ok: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
ok_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct26: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'\xf2)\x9e\xd6') # 0xf2299ed6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_frame))
data.write(b'\xc0,#O') # 0xc02c234f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.appear_sound))
data.write(b"'|\x04\xff") # 0x277c04ff
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.no_sound))
data.write(b'\x10\x8d\x90q') # 0x108d9071
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.yes_sound))
data.write(b'u\xach<') # 0x75ac683c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.animated_appear))
data.write(b'\x0c\x9c\x9c;') # 0xc9c9c3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x0c9c9c3b))
data.write(b'jj\xa4.') # 0x6a6aa42e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x6a6aa42e))
data.write(b'\x07\x8c\x81\x9f') # 0x78c819f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.animated_disappear))
data.write(b'K\x88>k') # 0x4b883e6b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.no))
data.write(b'9=\\x') # 0x393d5c78
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.no_core))
data.write(b'@\x01y\x17') # 0x40017917
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.yes))
data.write(b'\x10\x92"\x93') # 0x10922293
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.yes_core))
data.write(b'vnw\xc9') # 0x766e77c9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ok))
data.write(b'\xf1X#\xc2') # 0xf15823c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ok_core))
data.write(b'jY\x8a\x9b') # 0x6a598a9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
hud_frame=data['hud_frame'],
appear_sound=data['appear_sound'],
no_sound=data['no_sound'],
yes_sound=data['yes_sound'],
animated_appear=data['animated_appear'],
caud_0x0c9c9c3b=data['caud_0x0c9c9c3b'],
caud_0x6a6aa42e=data['caud_0x6a6aa42e'],
animated_disappear=data['animated_disappear'],
no=data['no'],
no_core=data['no_core'],
yes=data['yes'],
yes_core=data['yes_core'],
ok=data['ok'],
ok_core=data['ok_core'],
unknown_struct26=UnknownStruct26.from_json(data['unknown_struct26']),
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
'appear_sound': self.appear_sound,
'no_sound': self.no_sound,
'yes_sound': self.yes_sound,
'animated_appear': self.animated_appear,
'caud_0x0c9c9c3b': self.caud_0x0c9c9c3b,
'caud_0x6a6aa42e': self.caud_0x6a6aa42e,
'animated_disappear': self.animated_disappear,
'no': self.no,
'no_core': self.no_core,
'yes': self.yes,
'yes_core': self.yes_core,
'ok': self.ok,
'ok_core': self.ok_core,
'unknown_struct26': self.unknown_struct26.to_json(),
}
def _decode_hud_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_appear_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_no_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_yes_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animated_appear(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x0c9c9c3b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x6a6aa42e(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animated_disappear(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_no(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_no_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_yes(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_yes_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ok(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ok_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct26(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf2299ed6: ('hud_frame', _decode_hud_frame),
0xc02c234f: ('appear_sound', _decode_appear_sound),
0x277c04ff: ('no_sound', _decode_no_sound),
0x108d9071: ('yes_sound', _decode_yes_sound),
0x75ac683c: ('animated_appear', _decode_animated_appear),
0xc9c9c3b: ('caud_0x0c9c9c3b', _decode_caud_0x0c9c9c3b),
0x6a6aa42e: ('caud_0x6a6aa42e', _decode_caud_0x6a6aa42e),
0x78c819f: ('animated_disappear', _decode_animated_disappear),
0x4b883e6b: ('no', _decode_no),
0x393d5c78: ('no_core', _decode_no_core),
0x40017917: ('yes', _decode_yes),
0x10922293: ('yes_core', _decode_yes_core),
0x766e77c9: ('ok', _decode_ok),
0xf15823c2: ('ok_core', _decode_ok_core),
0x6a598a9b: ('unknown_struct26', _decode_unknown_struct26),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct28.py | 0.542863 | 0.16238 | UnknownStruct28.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct134(BaseProperty):
unknown_0x51e5c747: bool = dataclasses.field(default=False)
unknown_0x4046688f: bool = dataclasses.field(default=False)
replace_bounds: bool = dataclasses.field(default=False)
min_point: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
max_point: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'Q\xe5\xc7G') # 0x51e5c747
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x51e5c747))
data.write(b'@Fh\x8f') # 0x4046688f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4046688f))
data.write(b'\x99\x03~\x15') # 0x99037e15
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.replace_bounds))
data.write(b'H\xd6qk') # 0x48d6716b
data.write(b'\x00\x0c') # size
self.min_point.to_stream(data)
data.write(b'\xf1\xf0\xea\x1a') # 0xf1f0ea1a
data.write(b'\x00\x0c') # size
self.max_point.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x51e5c747=data['unknown_0x51e5c747'],
unknown_0x4046688f=data['unknown_0x4046688f'],
replace_bounds=data['replace_bounds'],
min_point=Vector.from_json(data['min_point']),
max_point=Vector.from_json(data['max_point']),
)
def to_json(self) -> dict:
return {
'unknown_0x51e5c747': self.unknown_0x51e5c747,
'unknown_0x4046688f': self.unknown_0x4046688f,
'replace_bounds': self.replace_bounds,
'min_point': self.min_point.to_json(),
'max_point': self.max_point.to_json(),
}
def _decode_unknown_0x51e5c747(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4046688f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_replace_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_min_point(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_max_point(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x51e5c747: ('unknown_0x51e5c747', _decode_unknown_0x51e5c747),
0x4046688f: ('unknown_0x4046688f', _decode_unknown_0x4046688f),
0x99037e15: ('replace_bounds', _decode_replace_bounds),
0x48d6716b: ('min_point', _decode_min_point),
0xf1f0ea1a: ('max_point', _decode_max_point),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct134.py | 0.698741 | 0.317413 | UnknownStruct134.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class StunnedByBopBehaviorData(BaseProperty):
stun_duration: float = dataclasses.field(default=3.0)
fall_to_ground_rule: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
can_be_stunned_in_air: bool = dataclasses.field(default=False)
override_terrain_alignment: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'-\x8d\xb3\x1d') # 0x2d8db31d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_duration))
data.write(b'u\x0e\xb3\xeb') # 0x750eb3eb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fall_to_ground_rule))
data.write(b'\xfe\x00\x86\xa4') # 0xfe0086a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_stunned_in_air))
data.write(b'\xff\x8b{\xa4') # 0xff8b7ba4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override_terrain_alignment))
@classmethod
def from_json(cls, data: dict):
return cls(
stun_duration=data['stun_duration'],
fall_to_ground_rule=data['fall_to_ground_rule'],
can_be_stunned_in_air=data['can_be_stunned_in_air'],
override_terrain_alignment=data['override_terrain_alignment'],
)
def to_json(self) -> dict:
return {
'stun_duration': self.stun_duration,
'fall_to_ground_rule': self.fall_to_ground_rule,
'can_be_stunned_in_air': self.can_be_stunned_in_air,
'override_terrain_alignment': self.override_terrain_alignment,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2d8db31d, 0x750eb3eb, 0xfe0086a4, 0xff8b7ba4)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[StunnedByBopBehaviorData]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHQLH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(38))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return StunnedByBopBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_stun_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fall_to_ground_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_can_be_stunned_in_air(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_override_terrain_alignment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2d8db31d: ('stun_duration', _decode_stun_duration),
0x750eb3eb: ('fall_to_ground_rule', _decode_fall_to_ground_rule),
0xfe0086a4: ('can_be_stunned_in_air', _decode_can_be_stunned_in_air),
0xff8b7ba4: ('override_terrain_alignment', _decode_override_terrain_alignment),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/StunnedByBopBehaviorData.py | 0.626696 | 0.274845 | StunnedByBopBehaviorData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.AnimGridModifierData import AnimGridModifierData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct85 import UnknownStruct85
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct86 import UnknownStruct86
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct87 import UnknownStruct87
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct88 import UnknownStruct88
@dataclasses.dataclass()
class UnknownStruct89(BaseProperty):
gravity: float = dataclasses.field(default=55.0)
snap_to_spline: bool = dataclasses.field(default=True)
unknown_0xdaccc7de: bool = dataclasses.field(default=True)
unknown_0xcff6090d: float = dataclasses.field(default=5.0)
disable_attack_time: float = dataclasses.field(default=0.6600000262260437)
minimum_toss_distance: float = dataclasses.field(default=10.0)
unknown_0xedf6ba25: float = dataclasses.field(default=3.0)
unknown_0x268ea25f: int = dataclasses.field(default=5)
anger_duration: float = dataclasses.field(default=3.5)
anim_grid: AnimGridModifierData = dataclasses.field(default_factory=AnimGridModifierData)
unknown_struct85: UnknownStruct85 = dataclasses.field(default_factory=UnknownStruct85)
unknown_struct86: UnknownStruct86 = dataclasses.field(default_factory=UnknownStruct86)
unknown_struct87: UnknownStruct87 = dataclasses.field(default_factory=UnknownStruct87)
unknown_struct88: UnknownStruct88 = dataclasses.field(default_factory=UnknownStruct88)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0e') # 14 properties
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'&\xec\xb99') # 0x26ecb939
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.snap_to_spline))
data.write(b'\xda\xcc\xc7\xde') # 0xdaccc7de
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xdaccc7de))
data.write(b'\xcf\xf6\t\r') # 0xcff6090d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcff6090d))
data.write(b'wJ\xc8<') # 0x774ac83c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_attack_time))
data.write(b'{\x95\xabG') # 0x7b95ab47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_toss_distance))
data.write(b'\xed\xf6\xba%') # 0xedf6ba25
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xedf6ba25))
data.write(b'&\x8e\xa2_') # 0x268ea25f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x268ea25f))
data.write(b': \xfb\x9b') # 0x3a20fb9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.anger_duration))
data.write(b'h\xfdI\xae') # 0x68fd49ae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.anim_grid.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xa8\x1fD') # 0xa81f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct85.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xac\xee\xf4+') # 0xaceef42b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct86.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1ed\xb8\xdf') # 0x1e64b8df
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct87.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x04\xde\xdf\x14') # 0x4dedf14
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct88.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
gravity=data['gravity'],
snap_to_spline=data['snap_to_spline'],
unknown_0xdaccc7de=data['unknown_0xdaccc7de'],
unknown_0xcff6090d=data['unknown_0xcff6090d'],
disable_attack_time=data['disable_attack_time'],
minimum_toss_distance=data['minimum_toss_distance'],
unknown_0xedf6ba25=data['unknown_0xedf6ba25'],
unknown_0x268ea25f=data['unknown_0x268ea25f'],
anger_duration=data['anger_duration'],
anim_grid=AnimGridModifierData.from_json(data['anim_grid']),
unknown_struct85=UnknownStruct85.from_json(data['unknown_struct85']),
unknown_struct86=UnknownStruct86.from_json(data['unknown_struct86']),
unknown_struct87=UnknownStruct87.from_json(data['unknown_struct87']),
unknown_struct88=UnknownStruct88.from_json(data['unknown_struct88']),
)
def to_json(self) -> dict:
return {
'gravity': self.gravity,
'snap_to_spline': self.snap_to_spline,
'unknown_0xdaccc7de': self.unknown_0xdaccc7de,
'unknown_0xcff6090d': self.unknown_0xcff6090d,
'disable_attack_time': self.disable_attack_time,
'minimum_toss_distance': self.minimum_toss_distance,
'unknown_0xedf6ba25': self.unknown_0xedf6ba25,
'unknown_0x268ea25f': self.unknown_0x268ea25f,
'anger_duration': self.anger_duration,
'anim_grid': self.anim_grid.to_json(),
'unknown_struct85': self.unknown_struct85.to_json(),
'unknown_struct86': self.unknown_struct86.to_json(),
'unknown_struct87': self.unknown_struct87.to_json(),
'unknown_struct88': self.unknown_struct88.to_json(),
}
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_snap_to_spline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xdaccc7de(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xcff6090d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disable_attack_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_toss_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xedf6ba25(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x268ea25f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_anger_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_anim_grid(data: typing.BinaryIO, property_size: int):
return AnimGridModifierData.from_stream(data, property_size)
def _decode_unknown_struct85(data: typing.BinaryIO, property_size: int):
return UnknownStruct85.from_stream(data, property_size)
def _decode_unknown_struct86(data: typing.BinaryIO, property_size: int):
return UnknownStruct86.from_stream(data, property_size)
def _decode_unknown_struct87(data: typing.BinaryIO, property_size: int):
return UnknownStruct87.from_stream(data, property_size)
def _decode_unknown_struct88(data: typing.BinaryIO, property_size: int):
return UnknownStruct88.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f2ae3e5: ('gravity', _decode_gravity),
0x26ecb939: ('snap_to_spline', _decode_snap_to_spline),
0xdaccc7de: ('unknown_0xdaccc7de', _decode_unknown_0xdaccc7de),
0xcff6090d: ('unknown_0xcff6090d', _decode_unknown_0xcff6090d),
0x774ac83c: ('disable_attack_time', _decode_disable_attack_time),
0x7b95ab47: ('minimum_toss_distance', _decode_minimum_toss_distance),
0xedf6ba25: ('unknown_0xedf6ba25', _decode_unknown_0xedf6ba25),
0x268ea25f: ('unknown_0x268ea25f', _decode_unknown_0x268ea25f),
0x3a20fb9b: ('anger_duration', _decode_anger_duration),
0x68fd49ae: ('anim_grid', _decode_anim_grid),
0xa81f44: ('unknown_struct85', _decode_unknown_struct85),
0xaceef42b: ('unknown_struct86', _decode_unknown_struct86),
0x1e64b8df: ('unknown_struct87', _decode_unknown_struct87),
0x4dedf14: ('unknown_struct88', _decode_unknown_struct88),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct89.py | 0.559771 | 0.270059 | UnknownStruct89.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class MoleTrainManagerStructA(BaseProperty):
unknown_0xee447d6b: bool = dataclasses.field(default=True)
unknown_0x4d765168: float = dataclasses.field(default=46.0)
unknown_0x4f01c9e2: float = dataclasses.field(default=36.0)
chase_offset: float = dataclasses.field(default=25.0)
chase_speed: float = dataclasses.field(default=11.0)
unknown_0xd33f6240: float = dataclasses.field(default=12.0)
chase_delay: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xeeD}k') # 0xee447d6b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xee447d6b))
data.write(b'MvQh') # 0x4d765168
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4d765168))
data.write(b'O\x01\xc9\xe2') # 0x4f01c9e2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4f01c9e2))
data.write(b'\xed\rh\x95') # 0xed0d6895
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chase_offset))
data.write(b'\x92\xfb\xc1a') # 0x92fbc161
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chase_speed))
data.write(b'\xd3?b@') # 0xd33f6240
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd33f6240))
data.write(b'\xe5\x96r\xb3') # 0xe59672b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chase_delay))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xee447d6b=data['unknown_0xee447d6b'],
unknown_0x4d765168=data['unknown_0x4d765168'],
unknown_0x4f01c9e2=data['unknown_0x4f01c9e2'],
chase_offset=data['chase_offset'],
chase_speed=data['chase_speed'],
unknown_0xd33f6240=data['unknown_0xd33f6240'],
chase_delay=data['chase_delay'],
)
def to_json(self) -> dict:
return {
'unknown_0xee447d6b': self.unknown_0xee447d6b,
'unknown_0x4d765168': self.unknown_0x4d765168,
'unknown_0x4f01c9e2': self.unknown_0x4f01c9e2,
'chase_offset': self.chase_offset,
'chase_speed': self.chase_speed,
'unknown_0xd33f6240': self.unknown_0xd33f6240,
'chase_delay': self.chase_delay,
}
_FAST_FORMAT = None
_FAST_IDS = (0xee447d6b, 0x4d765168, 0x4f01c9e2, 0xed0d6895, 0x92fbc161, 0xd33f6240, 0xe59672b3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MoleTrainManagerStructA]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(67))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return MoleTrainManagerStructA(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_unknown_0xee447d6b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4d765168(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4f01c9e2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chase_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chase_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd33f6240(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chase_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xee447d6b: ('unknown_0xee447d6b', _decode_unknown_0xee447d6b),
0x4d765168: ('unknown_0x4d765168', _decode_unknown_0x4d765168),
0x4f01c9e2: ('unknown_0x4f01c9e2', _decode_unknown_0x4f01c9e2),
0xed0d6895: ('chase_offset', _decode_chase_offset),
0x92fbc161: ('chase_speed', _decode_chase_speed),
0xd33f6240: ('unknown_0xd33f6240', _decode_unknown_0xd33f6240),
0xe59672b3: ('chase_delay', _decode_chase_delay),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MoleTrainManagerStructA.py | 0.63477 | 0.271209 | MoleTrainManagerStructA.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct186 import UnknownStruct186
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct187 import UnknownStruct187
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct188 import UnknownStruct188
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct189 import UnknownStruct189
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct190 import UnknownStruct190
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct191 import UnknownStruct191
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct54 import UnknownStruct54
@dataclasses.dataclass()
class UnknownStruct56(BaseProperty):
unknown_struct54: UnknownStruct54 = dataclasses.field(default_factory=UnknownStruct54)
unknown_struct186: UnknownStruct186 = dataclasses.field(default_factory=UnknownStruct186)
unknown_struct187: UnknownStruct187 = dataclasses.field(default_factory=UnknownStruct187)
unknown_struct188: UnknownStruct188 = dataclasses.field(default_factory=UnknownStruct188)
unknown_struct189: UnknownStruct189 = dataclasses.field(default_factory=UnknownStruct189)
unknown_struct190: UnknownStruct190 = dataclasses.field(default_factory=UnknownStruct190)
unknown_struct191: UnknownStruct191 = dataclasses.field(default_factory=UnknownStruct191)
frequency: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'E\xd3\x90\x80') # 0x45d39080
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct54.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D^\xf6i') # 0x445ef669
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct186.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xec\x8d\xb6\x00') # 0xec8db600
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct187.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc\xb0\x8a4') # 0xccb08a34
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct188.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01\x19|G') # 0x1197c47
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct189.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1@"\\') # 0xf140225c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct190.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbfE^\x0f') # 0xbf455e0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct191.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x98\xcb\xfe\xdc') # 0x98cbfedc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.frequency))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct54=UnknownStruct54.from_json(data['unknown_struct54']),
unknown_struct186=UnknownStruct186.from_json(data['unknown_struct186']),
unknown_struct187=UnknownStruct187.from_json(data['unknown_struct187']),
unknown_struct188=UnknownStruct188.from_json(data['unknown_struct188']),
unknown_struct189=UnknownStruct189.from_json(data['unknown_struct189']),
unknown_struct190=UnknownStruct190.from_json(data['unknown_struct190']),
unknown_struct191=UnknownStruct191.from_json(data['unknown_struct191']),
frequency=data['frequency'],
)
def to_json(self) -> dict:
return {
'unknown_struct54': self.unknown_struct54.to_json(),
'unknown_struct186': self.unknown_struct186.to_json(),
'unknown_struct187': self.unknown_struct187.to_json(),
'unknown_struct188': self.unknown_struct188.to_json(),
'unknown_struct189': self.unknown_struct189.to_json(),
'unknown_struct190': self.unknown_struct190.to_json(),
'unknown_struct191': self.unknown_struct191.to_json(),
'frequency': self.frequency,
}
def _decode_unknown_struct54(data: typing.BinaryIO, property_size: int):
return UnknownStruct54.from_stream(data, property_size)
def _decode_unknown_struct186(data: typing.BinaryIO, property_size: int):
return UnknownStruct186.from_stream(data, property_size)
def _decode_unknown_struct187(data: typing.BinaryIO, property_size: int):
return UnknownStruct187.from_stream(data, property_size)
def _decode_unknown_struct188(data: typing.BinaryIO, property_size: int):
return UnknownStruct188.from_stream(data, property_size)
def _decode_unknown_struct189(data: typing.BinaryIO, property_size: int):
return UnknownStruct189.from_stream(data, property_size)
def _decode_unknown_struct190(data: typing.BinaryIO, property_size: int):
return UnknownStruct190.from_stream(data, property_size)
def _decode_unknown_struct191(data: typing.BinaryIO, property_size: int):
return UnknownStruct191.from_stream(data, property_size)
def _decode_frequency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x45d39080: ('unknown_struct54', _decode_unknown_struct54),
0x445ef669: ('unknown_struct186', _decode_unknown_struct186),
0xec8db600: ('unknown_struct187', _decode_unknown_struct187),
0xccb08a34: ('unknown_struct188', _decode_unknown_struct188),
0x1197c47: ('unknown_struct189', _decode_unknown_struct189),
0xf140225c: ('unknown_struct190', _decode_unknown_struct190),
0xbf455e0f: ('unknown_struct191', _decode_unknown_struct191),
0x98cbfedc: ('frequency', _decode_frequency),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct56.py | 0.620277 | 0.230746 | UnknownStruct56.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class KongGrabData(BaseProperty):
grab_front_range: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.5, y=2.25, z=1.25))
grab_air_front_range: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.5, y=2.25, z=2.5))
grab_side_range: Vector = dataclasses.field(default_factory=lambda: Vector(x=3.0, y=1.899999976158142, z=1.25))
grab_side_offset: float = dataclasses.field(default=-0.6000000238418579)
throw_velocity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=25.0, z=5.0))
left_locator: str = dataclasses.field(default='')
right_locator: str = dataclasses.field(default='')
turn_locator: str = dataclasses.field(default='')
allow_held_object_ceiling_adjust: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'y\x7f\xa8b') # 0x797fa862
data.write(b'\x00\x0c') # size
self.grab_front_range.to_stream(data)
data.write(b'\xe9\x1a3\x95') # 0xe91a3395
data.write(b'\x00\x0c') # size
self.grab_air_front_range.to_stream(data)
data.write(b'C\xfd\xb8\xd0') # 0x43fdb8d0
data.write(b'\x00\x0c') # size
self.grab_side_range.to_stream(data)
data.write(b'\xb5^\xbd=') # 0xb55ebd3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grab_side_offset))
data.write(b'\xec\xaa/r') # 0xecaa2f72
data.write(b'\x00\x0c') # size
self.throw_velocity.to_stream(data)
data.write(b'T\xbcH\xa1') # 0x54bc48a1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.left_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdbl\xd2\xca') # 0xdb6cd2ca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.right_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'9A\xbc\x07') # 0x3941bc07
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.turn_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x02\xd6\xa9\x90') # 0x2d6a990
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_held_object_ceiling_adjust))
@classmethod
def from_json(cls, data: dict):
return cls(
grab_front_range=Vector.from_json(data['grab_front_range']),
grab_air_front_range=Vector.from_json(data['grab_air_front_range']),
grab_side_range=Vector.from_json(data['grab_side_range']),
grab_side_offset=data['grab_side_offset'],
throw_velocity=Vector.from_json(data['throw_velocity']),
left_locator=data['left_locator'],
right_locator=data['right_locator'],
turn_locator=data['turn_locator'],
allow_held_object_ceiling_adjust=data['allow_held_object_ceiling_adjust'],
)
def to_json(self) -> dict:
return {
'grab_front_range': self.grab_front_range.to_json(),
'grab_air_front_range': self.grab_air_front_range.to_json(),
'grab_side_range': self.grab_side_range.to_json(),
'grab_side_offset': self.grab_side_offset,
'throw_velocity': self.throw_velocity.to_json(),
'left_locator': self.left_locator,
'right_locator': self.right_locator,
'turn_locator': self.turn_locator,
'allow_held_object_ceiling_adjust': self.allow_held_object_ceiling_adjust,
}
def _decode_grab_front_range(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_grab_air_front_range(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_grab_side_range(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_grab_side_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_throw_velocity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_left_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_right_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_turn_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_allow_held_object_ceiling_adjust(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x797fa862: ('grab_front_range', _decode_grab_front_range),
0xe91a3395: ('grab_air_front_range', _decode_grab_air_front_range),
0x43fdb8d0: ('grab_side_range', _decode_grab_side_range),
0xb55ebd3d: ('grab_side_offset', _decode_grab_side_offset),
0xecaa2f72: ('throw_velocity', _decode_throw_velocity),
0x54bc48a1: ('left_locator', _decode_left_locator),
0xdb6cd2ca: ('right_locator', _decode_right_locator),
0x3941bc07: ('turn_locator', _decode_turn_locator),
0x2d6a990: ('allow_held_object_ceiling_adjust', _decode_allow_held_object_ceiling_adjust),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongGrabData.py | 0.663342 | 0.41745 | KongGrabData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class ProjectileRenderOptions(BaseProperty):
render_push_amount: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xf4\x96\x80=') # 0xf496803d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push_amount))
@classmethod
def from_json(cls, data: dict):
return cls(
render_push_amount=data['render_push_amount'],
)
def to_json(self) -> dict:
return {
'render_push_amount': self.render_push_amount,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf496803d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ProjectileRenderOptions]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return ProjectileRenderOptions(
dec[2],
)
def _decode_render_push_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf496803d: ('render_push_amount', _decode_render_push_amount),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileRenderOptions.py | 0.627609 | 0.31662 | ProjectileRenderOptions.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct51(BaseProperty):
spike_stick_time: float = dataclasses.field(default=2.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'8\xdbm\x0f') # 0x38db6d0f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spike_stick_time))
@classmethod
def from_json(cls, data: dict):
return cls(
spike_stick_time=data['spike_stick_time'],
)
def to_json(self) -> dict:
return {
'spike_stick_time': self.spike_stick_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0x38db6d0f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct51]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct51(
dec[2],
)
def _decode_spike_stick_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x38db6d0f: ('spike_stick_time', _decode_spike_stick_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct51.py | 0.619701 | 0.326352 | UnknownStruct51.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct34(BaseProperty):
hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
appear_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
disappear_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
change_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\xf2)\x9e\xd6') # 0xf2299ed6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_frame))
data.write(b'\xc0,#O') # 0xc02c234f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.appear_sound))
data.write(b'm&~\x88') # 0x6d267e88
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.disappear_sound))
data.write(b'\xb8\xe3C\xf5') # 0xb8e343f5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.change_sound))
data.write(b'\xfd\x95\xed*') # 0xfd95ed2a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.string_table))
@classmethod
def from_json(cls, data: dict):
return cls(
hud_frame=data['hud_frame'],
appear_sound=data['appear_sound'],
disappear_sound=data['disappear_sound'],
change_sound=data['change_sound'],
string_table=data['string_table'],
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
'appear_sound': self.appear_sound,
'disappear_sound': self.disappear_sound,
'change_sound': self.change_sound,
'string_table': self.string_table,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf2299ed6, 0xc02c234f, 0x6d267e88, 0xb8e343f5, 0xfd95ed2a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct34]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct34(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_hud_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_appear_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_disappear_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_change_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf2299ed6: ('hud_frame', _decode_hud_frame),
0xc02c234f: ('appear_sound', _decode_appear_sound),
0x6d267e88: ('disappear_sound', _decode_disappear_sound),
0xb8e343f5: ('change_sound', _decode_change_sound),
0xfd95ed2a: ('string_table', _decode_string_table),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct34.py | 0.573798 | 0.232016 | UnknownStruct34.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct278 import UnknownStruct278
@dataclasses.dataclass()
class UnknownStruct57(BaseProperty):
unknown_struct278: UnknownStruct278 = dataclasses.field(default_factory=UnknownStruct278)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x18X\xcb\xdb') # 0x1858cbdb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct278.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct278=UnknownStruct278.from_json(data['unknown_struct278']),
)
def to_json(self) -> dict:
return {
'unknown_struct278': self.unknown_struct278.to_json(),
}
def _decode_unknown_struct278(data: typing.BinaryIO, property_size: int):
return UnknownStruct278.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1858cbdb: ('unknown_struct278', _decode_unknown_struct278),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct57.py | 0.623148 | 0.280996 | UnknownStruct57.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class Sets(BaseProperty):
number_of_sets: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b"\xfc\x82'\xa7") # 0xfc8227a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_sets))
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_sets=data['number_of_sets'],
)
def to_json(self) -> dict:
return {
'number_of_sets': self.number_of_sets,
}
_FAST_FORMAT = None
_FAST_IDS = (0xfc8227a7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Sets]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return Sets(
dec[2],
)
def _decode_number_of_sets(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfc8227a7: ('number_of_sets', _decode_number_of_sets),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/Sets.py | 0.608361 | 0.315314 | Sets.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileRenderOptions import ProjectileRenderOptions
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct194 import UnknownStruct194
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct195 import UnknownStruct195
@dataclasses.dataclass()
class ProjectileRenderData(BaseProperty):
rendering_type: enums.RenderingType = dataclasses.field(default=enums.RenderingType.Unknown1)
unknown_struct194: UnknownStruct194 = dataclasses.field(default_factory=UnknownStruct194)
unknown_struct195: UnknownStruct195 = dataclasses.field(default_factory=UnknownStruct195)
projectile_render_options: ProjectileRenderOptions = dataclasses.field(default_factory=ProjectileRenderOptions)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x0b\x91\x85y') # 0xb918579
data.write(b'\x00\x04') # size
self.rendering_type.to_stream(data)
data.write(b'(\xe0v\xfd') # 0x28e076fd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct194.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c\xde[\xd9') # 0x8cde5bd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct195.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\xb2tp') # 0x5cb27470
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_render_options.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
rendering_type=enums.RenderingType.from_json(data['rendering_type']),
unknown_struct194=UnknownStruct194.from_json(data['unknown_struct194']),
unknown_struct195=UnknownStruct195.from_json(data['unknown_struct195']),
projectile_render_options=ProjectileRenderOptions.from_json(data['projectile_render_options']),
)
def to_json(self) -> dict:
return {
'rendering_type': self.rendering_type.to_json(),
'unknown_struct194': self.unknown_struct194.to_json(),
'unknown_struct195': self.unknown_struct195.to_json(),
'projectile_render_options': self.projectile_render_options.to_json(),
}
def _decode_rendering_type(data: typing.BinaryIO, property_size: int):
return enums.RenderingType.from_stream(data)
def _decode_unknown_struct194(data: typing.BinaryIO, property_size: int):
return UnknownStruct194.from_stream(data, property_size)
def _decode_unknown_struct195(data: typing.BinaryIO, property_size: int):
return UnknownStruct195.from_stream(data, property_size)
def _decode_projectile_render_options(data: typing.BinaryIO, property_size: int):
return ProjectileRenderOptions.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb918579: ('rendering_type', _decode_rendering_type),
0x28e076fd: ('unknown_struct194', _decode_unknown_struct194),
0x8cde5bd9: ('unknown_struct195', _decode_unknown_struct195),
0x5cb27470: ('projectile_render_options', _decode_projectile_render_options),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileRenderData.py | 0.630571 | 0.274783 | ProjectileRenderData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class ControlCommands(BaseProperty):
command: enums.Command = dataclasses.field(default=enums.Command.Unknown36)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'A\x8b4"') # 0x418b3422
data.write(b'\x00\x04') # size
self.command.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
command=enums.Command.from_json(data['command']),
)
def to_json(self) -> dict:
return {
'command': self.command.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x418b3422)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ControlCommands]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return ControlCommands(
enums.Command(dec[2]),
)
def _decode_command(data: typing.BinaryIO, property_size: int):
return enums.Command.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x418b3422: ('command', _decode_command),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ControlCommands.py | 0.633977 | 0.281551 | ControlCommands.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class TrackPlayer(BaseProperty):
target_scale_of_bounding_box_height: float = dataclasses.field(default=0.0)
maximum_track_distance_x: float = dataclasses.field(default=15.0)
full_left_distance: float = dataclasses.field(default=10.0)
full_right_distance: float = dataclasses.field(default=5.0)
maximum_track_distance_z: float = dataclasses.field(default=15.0)
full_up_distance: float = dataclasses.field(default=10.0)
full_down_distance: float = dataclasses.field(default=1.0)
position_offset_z: float = dataclasses.field(default=0.0)
axis_relationship: enums.AxisRelationship = dataclasses.field(default=enums.AxisRelationship.Unknown1)
tracking_speed_x: float = dataclasses.field(default=6.0)
tracking_speed_z: float = dataclasses.field(default=6.0)
position_from_locator: bool = dataclasses.field(default=False)
orient_from_locator: bool = dataclasses.field(default=False)
locator_name: str = dataclasses.field(default='')
override_locator_direction: bool = dataclasses.field(default=False)
locator_forward: enums.UnknownEnum2 = dataclasses.field(default=enums.UnknownEnum2.Unknown2)
locator_up: enums.UnknownEnum2 = dataclasses.field(default=enums.UnknownEnum2.Unknown3)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x11') # 17 properties
data.write(b'\xb2\x97\xf1\x86') # 0xb297f186
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_scale_of_bounding_box_height))
data.write(b'\xca>\x85\xc5') # 0xca3e85c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_track_distance_x))
data.write(b'\x03m\xc8\xdd') # 0x36dc8dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_left_distance))
data.write(b'7\xa1#6') # 0x37a12336
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_right_distance))
data.write(b'\x87\xf6$\xce') # 0x87f624ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_track_distance_z))
data.write(b'\xc4jV+') # 0xc46a562b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_up_distance))
data.write(b'X\xd2\x9f?') # 0x58d29f3f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_down_distance))
data.write(b'\xe0\x02\x9eJ') # 0xe0029e4a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.position_offset_z))
data.write(b'i\xfcAw') # 0x69fc4177
data.write(b'\x00\x04') # size
self.axis_relationship.to_stream(data)
data.write(b'\xa5ti\xd3') # 0xa57469d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tracking_speed_x))
data.write(b'\xe8\xbc\xc8\xd8') # 0xe8bcc8d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tracking_speed_z))
data.write(b'^0\x0b?') # 0x5e300b3f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.position_from_locator))
data.write(b'cVK\xa2') # 0x63564ba2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orient_from_locator))
data.write(b'\xfb\xc6\xc1\x10') # 0xfbc6c110
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.locator_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'0\xc3\x03h') # 0x30c30368
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override_locator_direction))
data.write(b'<8b\xf3') # 0x3c3862f3
data.write(b'\x00\x04') # size
self.locator_forward.to_stream(data)
data.write(b'/q\x14)') # 0x2f711429
data.write(b'\x00\x04') # size
self.locator_up.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
target_scale_of_bounding_box_height=data['target_scale_of_bounding_box_height'],
maximum_track_distance_x=data['maximum_track_distance_x'],
full_left_distance=data['full_left_distance'],
full_right_distance=data['full_right_distance'],
maximum_track_distance_z=data['maximum_track_distance_z'],
full_up_distance=data['full_up_distance'],
full_down_distance=data['full_down_distance'],
position_offset_z=data['position_offset_z'],
axis_relationship=enums.AxisRelationship.from_json(data['axis_relationship']),
tracking_speed_x=data['tracking_speed_x'],
tracking_speed_z=data['tracking_speed_z'],
position_from_locator=data['position_from_locator'],
orient_from_locator=data['orient_from_locator'],
locator_name=data['locator_name'],
override_locator_direction=data['override_locator_direction'],
locator_forward=enums.UnknownEnum2.from_json(data['locator_forward']),
locator_up=enums.UnknownEnum2.from_json(data['locator_up']),
)
def to_json(self) -> dict:
return {
'target_scale_of_bounding_box_height': self.target_scale_of_bounding_box_height,
'maximum_track_distance_x': self.maximum_track_distance_x,
'full_left_distance': self.full_left_distance,
'full_right_distance': self.full_right_distance,
'maximum_track_distance_z': self.maximum_track_distance_z,
'full_up_distance': self.full_up_distance,
'full_down_distance': self.full_down_distance,
'position_offset_z': self.position_offset_z,
'axis_relationship': self.axis_relationship.to_json(),
'tracking_speed_x': self.tracking_speed_x,
'tracking_speed_z': self.tracking_speed_z,
'position_from_locator': self.position_from_locator,
'orient_from_locator': self.orient_from_locator,
'locator_name': self.locator_name,
'override_locator_direction': self.override_locator_direction,
'locator_forward': self.locator_forward.to_json(),
'locator_up': self.locator_up.to_json(),
}
def _decode_target_scale_of_bounding_box_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_track_distance_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_full_left_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_full_right_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_track_distance_z(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_full_up_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_full_down_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_position_offset_z(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_axis_relationship(data: typing.BinaryIO, property_size: int):
return enums.AxisRelationship.from_stream(data)
def _decode_tracking_speed_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tracking_speed_z(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_position_from_locator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_orient_from_locator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_locator_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_override_locator_direction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_locator_forward(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum2.from_stream(data)
def _decode_locator_up(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum2.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb297f186: ('target_scale_of_bounding_box_height', _decode_target_scale_of_bounding_box_height),
0xca3e85c5: ('maximum_track_distance_x', _decode_maximum_track_distance_x),
0x36dc8dd: ('full_left_distance', _decode_full_left_distance),
0x37a12336: ('full_right_distance', _decode_full_right_distance),
0x87f624ce: ('maximum_track_distance_z', _decode_maximum_track_distance_z),
0xc46a562b: ('full_up_distance', _decode_full_up_distance),
0x58d29f3f: ('full_down_distance', _decode_full_down_distance),
0xe0029e4a: ('position_offset_z', _decode_position_offset_z),
0x69fc4177: ('axis_relationship', _decode_axis_relationship),
0xa57469d3: ('tracking_speed_x', _decode_tracking_speed_x),
0xe8bcc8d8: ('tracking_speed_z', _decode_tracking_speed_z),
0x5e300b3f: ('position_from_locator', _decode_position_from_locator),
0x63564ba2: ('orient_from_locator', _decode_orient_from_locator),
0xfbc6c110: ('locator_name', _decode_locator_name),
0x30c30368: ('override_locator_direction', _decode_override_locator_direction),
0x3c3862f3: ('locator_forward', _decode_locator_forward),
0x2f711429: ('locator_up', _decode_locator_up),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TrackPlayer.py | 0.686475 | 0.302893 | TrackPlayer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct14 import UnknownStruct14
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct67 import UnknownStruct67
@dataclasses.dataclass()
class UnknownStruct68(BaseProperty):
horizontal_type: enums.HorizontalType = dataclasses.field(default=enums.HorizontalType.Unknown1)
unknown_struct67: UnknownStruct67 = dataclasses.field(default_factory=UnknownStruct67)
unknown_struct14: UnknownStruct14 = dataclasses.field(default_factory=UnknownStruct14)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'+rG\xaa') # 0x2b7247aa
data.write(b'\x00\x04') # size
self.horizontal_type.to_stream(data)
data.write(b'\xb0*\xaaS') # 0xb02aaa53
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct67.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x02\xb7\x92C') # 0x2b79243
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct14.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
horizontal_type=enums.HorizontalType.from_json(data['horizontal_type']),
unknown_struct67=UnknownStruct67.from_json(data['unknown_struct67']),
unknown_struct14=UnknownStruct14.from_json(data['unknown_struct14']),
)
def to_json(self) -> dict:
return {
'horizontal_type': self.horizontal_type.to_json(),
'unknown_struct67': self.unknown_struct67.to_json(),
'unknown_struct14': self.unknown_struct14.to_json(),
}
def _decode_horizontal_type(data: typing.BinaryIO, property_size: int):
return enums.HorizontalType.from_stream(data)
def _decode_unknown_struct67(data: typing.BinaryIO, property_size: int):
return UnknownStruct67.from_stream(data, property_size)
def _decode_unknown_struct14(data: typing.BinaryIO, property_size: int):
return UnknownStruct14.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2b7247aa: ('horizontal_type', _decode_horizontal_type),
0xb02aaa53: ('unknown_struct67', _decode_unknown_struct67),
0x2b79243: ('unknown_struct14', _decode_unknown_struct14),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct68.py | 0.630344 | 0.280495 | UnknownStruct68.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct15(BaseProperty):
unknown_0xf38c4b4d: float = dataclasses.field(default=-1.5)
unknown_0xcd3dd32a: float = dataclasses.field(default=2.75)
unknown_0x8f6291d1: float = dataclasses.field(default=6.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xf3\x8cKM') # 0xf38c4b4d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf38c4b4d))
data.write(b'\xcd=\xd3*') # 0xcd3dd32a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcd3dd32a))
data.write(b'\x8fb\x91\xd1') # 0x8f6291d1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8f6291d1))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xf38c4b4d=data['unknown_0xf38c4b4d'],
unknown_0xcd3dd32a=data['unknown_0xcd3dd32a'],
unknown_0x8f6291d1=data['unknown_0x8f6291d1'],
)
def to_json(self) -> dict:
return {
'unknown_0xf38c4b4d': self.unknown_0xf38c4b4d,
'unknown_0xcd3dd32a': self.unknown_0xcd3dd32a,
'unknown_0x8f6291d1': self.unknown_0x8f6291d1,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf38c4b4d, 0xcd3dd32a, 0x8f6291d1)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct15]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct15(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown_0xf38c4b4d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcd3dd32a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8f6291d1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf38c4b4d: ('unknown_0xf38c4b4d', _decode_unknown_0xf38c4b4d),
0xcd3dd32a: ('unknown_0xcd3dd32a', _decode_unknown_0xcd3dd32a),
0x8f6291d1: ('unknown_0x8f6291d1', _decode_unknown_0x8f6291d1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct15.py | 0.630344 | 0.314577 | UnknownStruct15.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct9(BaseProperty):
unknown_0x5d28cce5: float = dataclasses.field(default=0.0)
unknown_0x1fe2e0b4: float = dataclasses.field(default=1.0)
lerp_duration: float = dataclasses.field(default=1.0)
unknown_0x9adf7732: bool = dataclasses.field(default=False)
unknown_0x7fbfe9fd: bool = dataclasses.field(default=True)
unknown_0x6a54d863: bool = dataclasses.field(default=False)
unknown_0x17d5302a: float = dataclasses.field(default=7.0)
unknown_0xfa271b70: bool = dataclasses.field(default=False)
unknown_0x5c927fb2: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'](\xcc\xe5') # 0x5d28cce5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5d28cce5))
data.write(b'\x1f\xe2\xe0\xb4') # 0x1fe2e0b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1fe2e0b4))
data.write(b'\x829\xd0L') # 0x8239d04c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lerp_duration))
data.write(b'\x9a\xdfw2') # 0x9adf7732
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x9adf7732))
data.write(b'\x7f\xbf\xe9\xfd') # 0x7fbfe9fd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7fbfe9fd))
data.write(b'jT\xd8c') # 0x6a54d863
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x6a54d863))
data.write(b'\x17\xd50*') # 0x17d5302a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x17d5302a))
data.write(b"\xfa'\x1bp") # 0xfa271b70
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xfa271b70))
data.write(b'\\\x92\x7f\xb2') # 0x5c927fb2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5c927fb2))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x5d28cce5=data['unknown_0x5d28cce5'],
unknown_0x1fe2e0b4=data['unknown_0x1fe2e0b4'],
lerp_duration=data['lerp_duration'],
unknown_0x9adf7732=data['unknown_0x9adf7732'],
unknown_0x7fbfe9fd=data['unknown_0x7fbfe9fd'],
unknown_0x6a54d863=data['unknown_0x6a54d863'],
unknown_0x17d5302a=data['unknown_0x17d5302a'],
unknown_0xfa271b70=data['unknown_0xfa271b70'],
unknown_0x5c927fb2=data['unknown_0x5c927fb2'],
)
def to_json(self) -> dict:
return {
'unknown_0x5d28cce5': self.unknown_0x5d28cce5,
'unknown_0x1fe2e0b4': self.unknown_0x1fe2e0b4,
'lerp_duration': self.lerp_duration,
'unknown_0x9adf7732': self.unknown_0x9adf7732,
'unknown_0x7fbfe9fd': self.unknown_0x7fbfe9fd,
'unknown_0x6a54d863': self.unknown_0x6a54d863,
'unknown_0x17d5302a': self.unknown_0x17d5302a,
'unknown_0xfa271b70': self.unknown_0xfa271b70,
'unknown_0x5c927fb2': self.unknown_0x5c927fb2,
}
_FAST_FORMAT = None
_FAST_IDS = (0x5d28cce5, 0x1fe2e0b4, 0x8239d04c, 0x9adf7732, 0x7fbfe9fd, 0x6a54d863, 0x17d5302a, 0xfa271b70, 0x5c927fb2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct9]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLH?LH?LH?LHfLH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(78))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct9(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_unknown_0x5d28cce5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1fe2e0b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lerp_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9adf7732(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7fbfe9fd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x6a54d863(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x17d5302a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfa271b70(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x5c927fb2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5d28cce5: ('unknown_0x5d28cce5', _decode_unknown_0x5d28cce5),
0x1fe2e0b4: ('unknown_0x1fe2e0b4', _decode_unknown_0x1fe2e0b4),
0x8239d04c: ('lerp_duration', _decode_lerp_duration),
0x9adf7732: ('unknown_0x9adf7732', _decode_unknown_0x9adf7732),
0x7fbfe9fd: ('unknown_0x7fbfe9fd', _decode_unknown_0x7fbfe9fd),
0x6a54d863: ('unknown_0x6a54d863', _decode_unknown_0x6a54d863),
0x17d5302a: ('unknown_0x17d5302a', _decode_unknown_0x17d5302a),
0xfa271b70: ('unknown_0xfa271b70', _decode_unknown_0xfa271b70),
0x5c927fb2: ('unknown_0x5c927fb2', _decode_unknown_0x5c927fb2),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct9.py | 0.590661 | 0.322446 | UnknownStruct9.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightMotionSpline(BaseProperty):
motion_spline_path_loops: bool = dataclasses.field(default=False)
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
motion_spline_duration: float = dataclasses.field(default=10.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'=t\x06\xaf') # 0x3d7406af
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.motion_spline_path_loops))
data.write(b'I=j-') # 0x493d6a2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x1e/V') # 0xfd1e2f56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.motion_spline_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
motion_spline_path_loops=data['motion_spline_path_loops'],
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
motion_spline_duration=data['motion_spline_duration'],
)
def to_json(self) -> dict:
return {
'motion_spline_path_loops': self.motion_spline_path_loops,
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'motion_spline_duration': self.motion_spline_duration,
}
def _decode_motion_spline_path_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_motion_spline_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x3d7406af: ('motion_spline_path_loops', _decode_motion_spline_path_loops),
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DynamicLightMotionSpline.py | 0.673514 | 0.270083 | DynamicLightMotionSpline.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct150(BaseProperty):
hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
frme: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
text_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
confirm_text_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
confirm_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
cancel_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xf2)\x9e\xd6') # 0xf2299ed6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_frame))
data.write(b'\xac.\x85\xfe') # 0xac2e85fe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.frme))
data.write(b'\xe6\xf6\xe2p') # 0xe6f6e270
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_string))
data.write(b'\x1a\xe1Ru') # 0x1ae15275
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.confirm_text_string))
data.write(b'O\xab\xac\t') # 0x4fabac09
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.confirm_string))
data.write(b'\xcbj\xf8\x9b') # 0xcb6af89b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cancel_string))
@classmethod
def from_json(cls, data: dict):
return cls(
hud_frame=data['hud_frame'],
frme=data['frme'],
text_string=data['text_string'],
confirm_text_string=data['confirm_text_string'],
confirm_string=data['confirm_string'],
cancel_string=data['cancel_string'],
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
'frme': self.frme,
'text_string': self.text_string,
'confirm_text_string': self.confirm_text_string,
'confirm_string': self.confirm_string,
'cancel_string': self.cancel_string,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf2299ed6, 0xac2e85fe, 0xe6f6e270, 0x1ae15275, 0x4fabac09, 0xcb6af89b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct150]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(84))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct150(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_hud_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_frme(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_confirm_text_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_confirm_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cancel_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf2299ed6: ('hud_frame', _decode_hud_frame),
0xac2e85fe: ('frme', _decode_frme),
0xe6f6e270: ('text_string', _decode_text_string),
0x1ae15275: ('confirm_text_string', _decode_confirm_text_string),
0x4fabac09: ('confirm_string', _decode_confirm_string),
0xcb6af89b: ('cancel_string', _decode_cancel_string),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct150.py | 0.557364 | 0.227362 | UnknownStruct150.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightSpotlight(BaseProperty):
spotlight_angle: Spline = dataclasses.field(default_factory=Spline)
spotlight_angle_duration: float = dataclasses.field(default=0.0)
spotlight_angle_loops: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xfe\xec\xa0\xd6') # 0xfeeca0d6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spotlight_angle.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'y\xaay\x8b') # 0x79aa798b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spotlight_angle_duration))
data.write(b'/\xd0\x83\x00') # 0x2fd08300
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spotlight_angle_loops))
@classmethod
def from_json(cls, data: dict):
return cls(
spotlight_angle=Spline.from_json(data['spotlight_angle']),
spotlight_angle_duration=data['spotlight_angle_duration'],
spotlight_angle_loops=data['spotlight_angle_loops'],
)
def to_json(self) -> dict:
return {
'spotlight_angle': self.spotlight_angle.to_json(),
'spotlight_angle_duration': self.spotlight_angle_duration,
'spotlight_angle_loops': self.spotlight_angle_loops,
}
def _decode_spotlight_angle(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_spotlight_angle_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spotlight_angle_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfeeca0d6: ('spotlight_angle', _decode_spotlight_angle),
0x79aa798b: ('spotlight_angle_duration', _decode_spotlight_angle_duration),
0x2fd08300: ('spotlight_angle_loops', _decode_spotlight_angle_loops),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DynamicLightSpotlight.py | 0.673406 | 0.344774 | DynamicLightSpotlight.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.VolcanoBossBodyPartStructA import VolcanoBossBodyPartStructA
@dataclasses.dataclass()
class UnknownStruct289(BaseProperty):
volcano_boss_body_part_struct_a: VolcanoBossBodyPartStructA = dataclasses.field(default_factory=VolcanoBossBodyPartStructA)
selection_chance: float = dataclasses.field(default=50.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'(\xf4\x9aS') # 0x28f49a53
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b\x03\x04f') # 0x1b030466
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.selection_chance))
@classmethod
def from_json(cls, data: dict):
return cls(
volcano_boss_body_part_struct_a=VolcanoBossBodyPartStructA.from_json(data['volcano_boss_body_part_struct_a']),
selection_chance=data['selection_chance'],
)
def to_json(self) -> dict:
return {
'volcano_boss_body_part_struct_a': self.volcano_boss_body_part_struct_a.to_json(),
'selection_chance': self.selection_chance,
}
def _decode_volcano_boss_body_part_struct_a(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructA.from_stream(data, property_size)
def _decode_selection_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x28f49a53: ('volcano_boss_body_part_struct_a', _decode_volcano_boss_body_part_struct_a),
0x1b030466: ('selection_chance', _decode_selection_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct289.py | 0.63307 | 0.350199 | UnknownStruct289.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerShieldSplineData import PlayerShieldSplineData
@dataclasses.dataclass()
class PlayerShieldData(BaseProperty):
num_splines: int = dataclasses.field(default=1)
spline1: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline2: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline3: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline4: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline5: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline6: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline7: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline8: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline9: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
spline10: PlayerShieldSplineData = dataclasses.field(default_factory=PlayerShieldSplineData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b"Z\x15\xd1'") # 0x5a15d127
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_splines))
data.write(b'\xcdB\r#') # 0xcd420d23
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbb\xa74\x1e') # 0xbba7341e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' \xd4\xde\xca') # 0x20d4deca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'VmFd') # 0x566d4664
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcd\x1e\xac\xb0') # 0xcd1eacb0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbb\xfb\x95\x8d') # 0xbbfb958d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' \x88\x7fY') # 0x20887f59
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\x88\xa4\xd1') # 0x5688a4d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcd\xfbN\x05') # 0xcdfb4e05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xec{|M') # 0xec7b7c4d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline10.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
num_splines=data['num_splines'],
spline1=PlayerShieldSplineData.from_json(data['spline1']),
spline2=PlayerShieldSplineData.from_json(data['spline2']),
spline3=PlayerShieldSplineData.from_json(data['spline3']),
spline4=PlayerShieldSplineData.from_json(data['spline4']),
spline5=PlayerShieldSplineData.from_json(data['spline5']),
spline6=PlayerShieldSplineData.from_json(data['spline6']),
spline7=PlayerShieldSplineData.from_json(data['spline7']),
spline8=PlayerShieldSplineData.from_json(data['spline8']),
spline9=PlayerShieldSplineData.from_json(data['spline9']),
spline10=PlayerShieldSplineData.from_json(data['spline10']),
)
def to_json(self) -> dict:
return {
'num_splines': self.num_splines,
'spline1': self.spline1.to_json(),
'spline2': self.spline2.to_json(),
'spline3': self.spline3.to_json(),
'spline4': self.spline4.to_json(),
'spline5': self.spline5.to_json(),
'spline6': self.spline6.to_json(),
'spline7': self.spline7.to_json(),
'spline8': self.spline8.to_json(),
'spline9': self.spline9.to_json(),
'spline10': self.spline10.to_json(),
}
def _decode_num_splines(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spline1(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline2(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline3(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline4(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline5(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline6(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline7(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline8(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline9(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
def _decode_spline10(data: typing.BinaryIO, property_size: int):
return PlayerShieldSplineData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5a15d127: ('num_splines', _decode_num_splines),
0xcd420d23: ('spline1', _decode_spline1),
0xbba7341e: ('spline2', _decode_spline2),
0x20d4deca: ('spline3', _decode_spline3),
0x566d4664: ('spline4', _decode_spline4),
0xcd1eacb0: ('spline5', _decode_spline5),
0xbbfb958d: ('spline6', _decode_spline6),
0x20887f59: ('spline7', _decode_spline7),
0x5688a4d1: ('spline8', _decode_spline8),
0xcdfb4e05: ('spline9', _decode_spline9),
0xec7b7c4d: ('spline10', _decode_spline10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerShieldData.py | 0.532668 | 0.349422 | PlayerShieldData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class SpringConvergence(BaseProperty):
critically_dampened: bool = dataclasses.field(default=True)
spring_constant: float = dataclasses.field(default=10.0)
dampen_constant: float = dataclasses.field(default=0.0)
threshold: float = dataclasses.field(default=0.009999999776482582)
spring_max: float = dataclasses.field(default=10.0)
tardis: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'o\xa2\xf8\xbc') # 0x6fa2f8bc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.critically_dampened))
data.write(b'\xb3\x828c') # 0xb3823863
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spring_constant))
data.write(b'\xb1"\xa1\x8d') # 0xb122a18d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dampen_constant))
data.write(b'\x8e\x1b\x83\xf9') # 0x8e1b83f9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.threshold))
data.write(b'\xac\xb1\xcd\xcb') # 0xacb1cdcb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spring_max))
data.write(b't\xd1\x158') # 0x74d11538
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tardis))
@classmethod
def from_json(cls, data: dict):
return cls(
critically_dampened=data['critically_dampened'],
spring_constant=data['spring_constant'],
dampen_constant=data['dampen_constant'],
threshold=data['threshold'],
spring_max=data['spring_max'],
tardis=data['tardis'],
)
def to_json(self) -> dict:
return {
'critically_dampened': self.critically_dampened,
'spring_constant': self.spring_constant,
'dampen_constant': self.dampen_constant,
'threshold': self.threshold,
'spring_max': self.spring_max,
'tardis': self.tardis,
}
_FAST_FORMAT = None
_FAST_IDS = (0x6fa2f8bc, 0xb3823863, 0xb122a18d, 0x8e1b83f9, 0xacb1cdcb, 0x74d11538)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SpringConvergence]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(57))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return SpringConvergence(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_critically_dampened(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_spring_constant(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dampen_constant(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spring_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tardis(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6fa2f8bc: ('critically_dampened', _decode_critically_dampened),
0xb3823863: ('spring_constant', _decode_spring_constant),
0xb122a18d: ('dampen_constant', _decode_dampen_constant),
0x8e1b83f9: ('threshold', _decode_threshold),
0xacb1cdcb: ('spring_max', _decode_spring_max),
0x74d11538: ('tardis', _decode_tardis),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SpringConvergence.py | 0.630002 | 0.338227 | SpringConvergence.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class TargetPlayerBehaviorData(BaseProperty):
mode: int = dataclasses.field(default=1638556020) # Choice
start_targeting_range: float = dataclasses.field(default=15.0)
stop_targeting_range: float = dataclasses.field(default=25.0)
rotation_speed: float = dataclasses.field(default=1440.0)
telegraph_loops: bool = dataclasses.field(default=True)
telegraph_time: float = dataclasses.field(default=2.0)
min_target_distance: float = dataclasses.field(default=0.10000000149011612)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mode))
data.write(b'\x11e\xa5\x1e') # 0x1165a51e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_targeting_range))
data.write(b'\xfaW9\x8b') # 0xfa57398b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stop_targeting_range))
data.write(b'\x11\xcd\x07o') # 0x11cd076f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotation_speed))
data.write(b'^\xa8\x0f\x07') # 0x5ea80f07
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.telegraph_loops))
data.write(b'\x8ek\xbe\xf1') # 0x8e6bbef1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.telegraph_time))
data.write(b'\xfajWa') # 0xfa6a5761
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_target_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
mode=data['mode'],
start_targeting_range=data['start_targeting_range'],
stop_targeting_range=data['stop_targeting_range'],
rotation_speed=data['rotation_speed'],
telegraph_loops=data['telegraph_loops'],
telegraph_time=data['telegraph_time'],
min_target_distance=data['min_target_distance'],
)
def to_json(self) -> dict:
return {
'mode': self.mode,
'start_targeting_range': self.start_targeting_range,
'stop_targeting_range': self.stop_targeting_range,
'rotation_speed': self.rotation_speed,
'telegraph_loops': self.telegraph_loops,
'telegraph_time': self.telegraph_time,
'min_target_distance': self.min_target_distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb8f60f9a, 0x1165a51e, 0xfa57398b, 0x11cd076f, 0x5ea80f07, 0x8e6bbef1, 0xfa6a5761)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TargetPlayerBehaviorData]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHfLH?LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(67))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return TargetPlayerBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_start_targeting_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stop_targeting_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_telegraph_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_telegraph_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_target_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb8f60f9a: ('mode', _decode_mode),
0x1165a51e: ('start_targeting_range', _decode_start_targeting_range),
0xfa57398b: ('stop_targeting_range', _decode_stop_targeting_range),
0x11cd076f: ('rotation_speed', _decode_rotation_speed),
0x5ea80f07: ('telegraph_loops', _decode_telegraph_loops),
0x8e6bbef1: ('telegraph_time', _decode_telegraph_time),
0xfa6a5761: ('min_target_distance', _decode_min_target_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TargetPlayerBehaviorData.py | 0.698741 | 0.313853 | TargetPlayerBehaviorData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class ZoomBehaviorData(BaseProperty):
pullback_spline: Spline = dataclasses.field(default_factory=Spline)
zoom_by_horizontal_distance: bool = dataclasses.field(default=True)
zoom_by_vertical_distance: bool = dataclasses.field(default=False)
vertical_distance_ratio: float = dataclasses.field(default=1.7769999504089355)
zoom_by_distance_from_ground: bool = dataclasses.field(default=False)
pullback_spline_from_ground: Spline = dataclasses.field(default_factory=Spline)
adjust_horizontally: bool = dataclasses.field(default=True)
adjust_vertically: bool = dataclasses.field(default=True)
zoom_in_delay: float = dataclasses.field(default=1.5)
zoom_motion: Convergence = dataclasses.field(default_factory=Convergence)
horizontal_adjust_motion: Convergence = dataclasses.field(default_factory=Convergence)
get_max_zoom_from_zoom_spline: bool = dataclasses.field(default=False)
max_distance_from_target: float = dataclasses.field(default=30.5)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\r') # 13 properties
data.write(b'4:\x18\xa7') # 0x343a18a7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pullback_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82\xaf7\x1e') # 0x82af371e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.zoom_by_horizontal_distance))
data.write(b'ov\xec^') # 0x6f76ec5e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.zoom_by_vertical_distance))
data.write(b'm\x18\xc3\x18') # 0x6d18c318
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vertical_distance_ratio))
data.write(b'\xac\xe2:\xc6') # 0xace23ac6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.zoom_by_distance_from_ground))
data.write(b'-\x83\x9eo') # 0x2d839e6f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pullback_spline_from_ground.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\x8d~\xf2') # 0xf88d7ef2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.adjust_horizontally))
data.write(b'\x90n\x98\xfa') # 0x906e98fa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.adjust_vertically))
data.write(b'\rl\x95)') # 0xd6c9529
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.zoom_in_delay))
data.write(b'\t/\x7f\xd8') # 0x92f7fd8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.zoom_motion.to_stream(data, default_override={'convergence_type': enums.ConvergenceType.Unknown1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b')\xe0b\x13') # 0x29e06213
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.horizontal_adjust_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2\x1eg\xc8') # 0xb21e67c8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.get_max_zoom_from_zoom_spline))
data.write(b'\x05O\x1a\x14') # 0x54f1a14
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_distance_from_target))
@classmethod
def from_json(cls, data: dict):
return cls(
pullback_spline=Spline.from_json(data['pullback_spline']),
zoom_by_horizontal_distance=data['zoom_by_horizontal_distance'],
zoom_by_vertical_distance=data['zoom_by_vertical_distance'],
vertical_distance_ratio=data['vertical_distance_ratio'],
zoom_by_distance_from_ground=data['zoom_by_distance_from_ground'],
pullback_spline_from_ground=Spline.from_json(data['pullback_spline_from_ground']),
adjust_horizontally=data['adjust_horizontally'],
adjust_vertically=data['adjust_vertically'],
zoom_in_delay=data['zoom_in_delay'],
zoom_motion=Convergence.from_json(data['zoom_motion']),
horizontal_adjust_motion=Convergence.from_json(data['horizontal_adjust_motion']),
get_max_zoom_from_zoom_spline=data['get_max_zoom_from_zoom_spline'],
max_distance_from_target=data['max_distance_from_target'],
)
def to_json(self) -> dict:
return {
'pullback_spline': self.pullback_spline.to_json(),
'zoom_by_horizontal_distance': self.zoom_by_horizontal_distance,
'zoom_by_vertical_distance': self.zoom_by_vertical_distance,
'vertical_distance_ratio': self.vertical_distance_ratio,
'zoom_by_distance_from_ground': self.zoom_by_distance_from_ground,
'pullback_spline_from_ground': self.pullback_spline_from_ground.to_json(),
'adjust_horizontally': self.adjust_horizontally,
'adjust_vertically': self.adjust_vertically,
'zoom_in_delay': self.zoom_in_delay,
'zoom_motion': self.zoom_motion.to_json(),
'horizontal_adjust_motion': self.horizontal_adjust_motion.to_json(),
'get_max_zoom_from_zoom_spline': self.get_max_zoom_from_zoom_spline,
'max_distance_from_target': self.max_distance_from_target,
}
def _decode_pullback_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_zoom_by_horizontal_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_zoom_by_vertical_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_vertical_distance_ratio(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_zoom_by_distance_from_ground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_pullback_spline_from_ground(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_adjust_horizontally(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_adjust_vertically(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_zoom_in_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_zoom_motion(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size, default_override={'convergence_type': enums.ConvergenceType.Unknown1})
def _decode_horizontal_adjust_motion(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_get_max_zoom_from_zoom_spline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_distance_from_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x343a18a7: ('pullback_spline', _decode_pullback_spline),
0x82af371e: ('zoom_by_horizontal_distance', _decode_zoom_by_horizontal_distance),
0x6f76ec5e: ('zoom_by_vertical_distance', _decode_zoom_by_vertical_distance),
0x6d18c318: ('vertical_distance_ratio', _decode_vertical_distance_ratio),
0xace23ac6: ('zoom_by_distance_from_ground', _decode_zoom_by_distance_from_ground),
0x2d839e6f: ('pullback_spline_from_ground', _decode_pullback_spline_from_ground),
0xf88d7ef2: ('adjust_horizontally', _decode_adjust_horizontally),
0x906e98fa: ('adjust_vertically', _decode_adjust_vertically),
0xd6c9529: ('zoom_in_delay', _decode_zoom_in_delay),
0x92f7fd8: ('zoom_motion', _decode_zoom_motion),
0x29e06213: ('horizontal_adjust_motion', _decode_horizontal_adjust_motion),
0xb21e67c8: ('get_max_zoom_from_zoom_spline', _decode_get_max_zoom_from_zoom_spline),
0x54f1a14: ('max_distance_from_target', _decode_max_distance_from_target),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ZoomBehaviorData.py | 0.61855 | 0.240674 | ZoomBehaviorData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct173(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
music_names: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xc8G\xc0') # 0x17c847c0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title_strings))
data.write(b'7\xfd\x19\x13') # 0x37fd1913
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction))
data.write(b'\xa1O4\xca') # 0xa14f34ca
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction_core))
data.write(b'\x1b\xd68Y') # 0x1bd63859
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.music_names))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title_strings=data['title_strings'],
instruction=data['instruction'],
instruction_core=data['instruction_core'],
music_names=data['music_names'],
back=data['back'],
back_core=data['back_core'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title_strings': self.title_strings,
'instruction': self.instruction,
'instruction_core': self.instruction_core,
'music_names': self.music_names,
'back': self.back,
'back_core': self.back_core,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_music_names(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0x17c847c0: ('title_strings', _decode_title_strings),
0x37fd1913: ('instruction', _decode_instruction),
0xa14f34ca: ('instruction_core', _decode_instruction_core),
0x1bd63859: ('music_names', _decode_music_names),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct173.py | 0.607197 | 0.201381 | UnknownStruct173.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.BirdBossStruct import BirdBossStruct
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct63 import UnknownStruct63
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct64 import UnknownStruct64
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class BirdBossData(BaseProperty):
snap_to_spline: bool = dataclasses.field(default=True)
floor_height: float = dataclasses.field(default=4.0)
gravity: float = dataclasses.field(default=55.0)
unknown_0x9ab09e44: float = dataclasses.field(default=10.0)
maximum_twist_speed: float = dataclasses.field(default=6.0)
unknown_0xa9a4e87c: str = dataclasses.field(default='')
unknown_0x61348354: float = dataclasses.field(default=7.0)
unknown_0x4eebc0c9: float = dataclasses.field(default=10.0)
unknown_0xeb300034: float = dataclasses.field(default=14.0)
unknown_0x65a1308e: float = dataclasses.field(default=17.0)
unknown_0x03554c19: float = dataclasses.field(default=0.0)
unknown_0x62ca94f2: float = dataclasses.field(default=2.0)
unknown_0xe33f5cd6: float = dataclasses.field(default=-5.0)
unknown_0xd486f8fe: float = dataclasses.field(default=-20.0)
unknown_0x3a18c538: float = dataclasses.field(default=10.0)
unknown_0xd9080460: float = dataclasses.field(default=4.0)
unknown_0xae96d690: float = dataclasses.field(default=2.0)
unknown_0xa8935c73: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x91ebf133: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_struct63: UnknownStruct63 = dataclasses.field(default_factory=UnknownStruct63)
unknown_struct64: UnknownStruct64 = dataclasses.field(default_factory=UnknownStruct64)
bird_boss_struct_0x3e67cc4a: BirdBossStruct = dataclasses.field(default_factory=BirdBossStruct)
bird_boss_struct_0xd4e11128: BirdBossStruct = dataclasses.field(default_factory=BirdBossStruct)
bird_boss_struct_0x3bb3a7c9: BirdBossStruct = dataclasses.field(default_factory=BirdBossStruct)
bird_boss_struct_0xda9dadad: BirdBossStruct = dataclasses.field(default_factory=BirdBossStruct)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x19') # 25 properties
data.write(b'&\xec\xb99') # 0x26ecb939
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.snap_to_spline))
data.write(b'\x04\x1d\xa1r') # 0x41da172
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_height))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\x9a\xb0\x9eD') # 0x9ab09e44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9ab09e44))
data.write(b'\xa0\xef\xda\x8e') # 0xa0efda8e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_twist_speed))
data.write(b'\xa9\xa4\xe8|') # 0xa9a4e87c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xa9a4e87c.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a4\x83T') # 0x61348354
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61348354))
data.write(b'N\xeb\xc0\xc9') # 0x4eebc0c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4eebc0c9))
data.write(b'\xeb0\x004') # 0xeb300034
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xeb300034))
data.write(b'e\xa10\x8e') # 0x65a1308e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x65a1308e))
data.write(b'\x03UL\x19') # 0x3554c19
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x03554c19))
data.write(b'b\xca\x94\xf2') # 0x62ca94f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x62ca94f2))
data.write(b'\xe3?\\\xd6') # 0xe33f5cd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe33f5cd6))
data.write(b'\xd4\x86\xf8\xfe') # 0xd486f8fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd486f8fe))
data.write(b':\x18\xc58') # 0x3a18c538
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3a18c538))
data.write(b'\xd9\x08\x04`') # 0xd9080460
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd9080460))
data.write(b'\xae\x96\xd6\x90') # 0xae96d690
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xae96d690))
data.write(b'\xa8\x93\\s') # 0xa8935c73
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xa8935c73.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xeb\xf13') # 0x91ebf133
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x91ebf133.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf0>\xb9^') # 0xf03eb95e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct63.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[\x1c\x94\xd1') # 0x5b1c94d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct64.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'>g\xccJ') # 0x3e67cc4a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bird_boss_struct_0x3e67cc4a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd4\xe1\x11(') # 0xd4e11128
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bird_boss_struct_0xd4e11128.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\xb3\xa7\xc9') # 0x3bb3a7c9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bird_boss_struct_0x3bb3a7c9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xda\x9d\xad\xad') # 0xda9dadad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bird_boss_struct_0xda9dadad.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
snap_to_spline=data['snap_to_spline'],
floor_height=data['floor_height'],
gravity=data['gravity'],
unknown_0x9ab09e44=data['unknown_0x9ab09e44'],
maximum_twist_speed=data['maximum_twist_speed'],
unknown_0xa9a4e87c=data['unknown_0xa9a4e87c'],
unknown_0x61348354=data['unknown_0x61348354'],
unknown_0x4eebc0c9=data['unknown_0x4eebc0c9'],
unknown_0xeb300034=data['unknown_0xeb300034'],
unknown_0x65a1308e=data['unknown_0x65a1308e'],
unknown_0x03554c19=data['unknown_0x03554c19'],
unknown_0x62ca94f2=data['unknown_0x62ca94f2'],
unknown_0xe33f5cd6=data['unknown_0xe33f5cd6'],
unknown_0xd486f8fe=data['unknown_0xd486f8fe'],
unknown_0x3a18c538=data['unknown_0x3a18c538'],
unknown_0xd9080460=data['unknown_0xd9080460'],
unknown_0xae96d690=data['unknown_0xae96d690'],
unknown_0xa8935c73=AnimationParameters.from_json(data['unknown_0xa8935c73']),
unknown_0x91ebf133=AnimationParameters.from_json(data['unknown_0x91ebf133']),
unknown_struct63=UnknownStruct63.from_json(data['unknown_struct63']),
unknown_struct64=UnknownStruct64.from_json(data['unknown_struct64']),
bird_boss_struct_0x3e67cc4a=BirdBossStruct.from_json(data['bird_boss_struct_0x3e67cc4a']),
bird_boss_struct_0xd4e11128=BirdBossStruct.from_json(data['bird_boss_struct_0xd4e11128']),
bird_boss_struct_0x3bb3a7c9=BirdBossStruct.from_json(data['bird_boss_struct_0x3bb3a7c9']),
bird_boss_struct_0xda9dadad=BirdBossStruct.from_json(data['bird_boss_struct_0xda9dadad']),
)
def to_json(self) -> dict:
return {
'snap_to_spline': self.snap_to_spline,
'floor_height': self.floor_height,
'gravity': self.gravity,
'unknown_0x9ab09e44': self.unknown_0x9ab09e44,
'maximum_twist_speed': self.maximum_twist_speed,
'unknown_0xa9a4e87c': self.unknown_0xa9a4e87c,
'unknown_0x61348354': self.unknown_0x61348354,
'unknown_0x4eebc0c9': self.unknown_0x4eebc0c9,
'unknown_0xeb300034': self.unknown_0xeb300034,
'unknown_0x65a1308e': self.unknown_0x65a1308e,
'unknown_0x03554c19': self.unknown_0x03554c19,
'unknown_0x62ca94f2': self.unknown_0x62ca94f2,
'unknown_0xe33f5cd6': self.unknown_0xe33f5cd6,
'unknown_0xd486f8fe': self.unknown_0xd486f8fe,
'unknown_0x3a18c538': self.unknown_0x3a18c538,
'unknown_0xd9080460': self.unknown_0xd9080460,
'unknown_0xae96d690': self.unknown_0xae96d690,
'unknown_0xa8935c73': self.unknown_0xa8935c73.to_json(),
'unknown_0x91ebf133': self.unknown_0x91ebf133.to_json(),
'unknown_struct63': self.unknown_struct63.to_json(),
'unknown_struct64': self.unknown_struct64.to_json(),
'bird_boss_struct_0x3e67cc4a': self.bird_boss_struct_0x3e67cc4a.to_json(),
'bird_boss_struct_0xd4e11128': self.bird_boss_struct_0xd4e11128.to_json(),
'bird_boss_struct_0x3bb3a7c9': self.bird_boss_struct_0x3bb3a7c9.to_json(),
'bird_boss_struct_0xda9dadad': self.bird_boss_struct_0xda9dadad.to_json(),
}
def _decode_snap_to_spline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_floor_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9ab09e44(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_twist_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa9a4e87c(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x61348354(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4eebc0c9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xeb300034(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x65a1308e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x03554c19(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x62ca94f2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe33f5cd6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd486f8fe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3a18c538(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd9080460(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xae96d690(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa8935c73(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x91ebf133(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_struct63(data: typing.BinaryIO, property_size: int):
return UnknownStruct63.from_stream(data, property_size)
def _decode_unknown_struct64(data: typing.BinaryIO, property_size: int):
return UnknownStruct64.from_stream(data, property_size)
def _decode_bird_boss_struct_0x3e67cc4a(data: typing.BinaryIO, property_size: int):
return BirdBossStruct.from_stream(data, property_size)
def _decode_bird_boss_struct_0xd4e11128(data: typing.BinaryIO, property_size: int):
return BirdBossStruct.from_stream(data, property_size)
def _decode_bird_boss_struct_0x3bb3a7c9(data: typing.BinaryIO, property_size: int):
return BirdBossStruct.from_stream(data, property_size)
def _decode_bird_boss_struct_0xda9dadad(data: typing.BinaryIO, property_size: int):
return BirdBossStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x26ecb939: ('snap_to_spline', _decode_snap_to_spline),
0x41da172: ('floor_height', _decode_floor_height),
0x2f2ae3e5: ('gravity', _decode_gravity),
0x9ab09e44: ('unknown_0x9ab09e44', _decode_unknown_0x9ab09e44),
0xa0efda8e: ('maximum_twist_speed', _decode_maximum_twist_speed),
0xa9a4e87c: ('unknown_0xa9a4e87c', _decode_unknown_0xa9a4e87c),
0x61348354: ('unknown_0x61348354', _decode_unknown_0x61348354),
0x4eebc0c9: ('unknown_0x4eebc0c9', _decode_unknown_0x4eebc0c9),
0xeb300034: ('unknown_0xeb300034', _decode_unknown_0xeb300034),
0x65a1308e: ('unknown_0x65a1308e', _decode_unknown_0x65a1308e),
0x3554c19: ('unknown_0x03554c19', _decode_unknown_0x03554c19),
0x62ca94f2: ('unknown_0x62ca94f2', _decode_unknown_0x62ca94f2),
0xe33f5cd6: ('unknown_0xe33f5cd6', _decode_unknown_0xe33f5cd6),
0xd486f8fe: ('unknown_0xd486f8fe', _decode_unknown_0xd486f8fe),
0x3a18c538: ('unknown_0x3a18c538', _decode_unknown_0x3a18c538),
0xd9080460: ('unknown_0xd9080460', _decode_unknown_0xd9080460),
0xae96d690: ('unknown_0xae96d690', _decode_unknown_0xae96d690),
0xa8935c73: ('unknown_0xa8935c73', _decode_unknown_0xa8935c73),
0x91ebf133: ('unknown_0x91ebf133', _decode_unknown_0x91ebf133),
0xf03eb95e: ('unknown_struct63', _decode_unknown_struct63),
0x5b1c94d1: ('unknown_struct64', _decode_unknown_struct64),
0x3e67cc4a: ('bird_boss_struct_0x3e67cc4a', _decode_bird_boss_struct_0x3e67cc4a),
0xd4e11128: ('bird_boss_struct_0xd4e11128', _decode_bird_boss_struct_0xd4e11128),
0x3bb3a7c9: ('bird_boss_struct_0x3bb3a7c9', _decode_bird_boss_struct_0x3bb3a7c9),
0xda9dadad: ('bird_boss_struct_0xda9dadad', _decode_bird_boss_struct_0xda9dadad),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BirdBossData.py | 0.621426 | 0.253117 | BirdBossData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class GenericCreatureStructE(BaseProperty):
animation: int = dataclasses.field(default=0)
group: int = dataclasses.field(default=1)
loop: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xaa\xcd\xb1\x1c') # 0xaacdb11c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation))
data.write(b'\x8a\xcd[o') # 0x8acd5b6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.group))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
@classmethod
def from_json(cls, data: dict):
return cls(
animation=data['animation'],
group=data['group'],
loop=data['loop'],
)
def to_json(self) -> dict:
return {
'animation': self.animation,
'group': self.group,
'loop': self.loop,
}
_FAST_FORMAT = None
_FAST_IDS = (0xaacdb11c, 0x8acd5b6f, 0xeda47ff6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[GenericCreatureStructE]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(27))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return GenericCreatureStructE(
dec[2],
dec[5],
dec[8],
)
def _decode_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_group(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xaacdb11c: ('animation', _decode_animation),
0x8acd5b6f: ('group', _decode_group),
0xeda47ff6: ('loop', _decode_loop),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GenericCreatureStructE.py | 0.589244 | 0.298741 | GenericCreatureStructE.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct264(BaseProperty):
unknown: bool = dataclasses.field(default=False)
is_percentage: bool = dataclasses.field(default=False)
percentage_chance: int = dataclasses.field(default=50)
minimum_count: int = dataclasses.field(default=1)
maximum_count: int = dataclasses.field(default=1)
minimum_percentage: int = dataclasses.field(default=50)
maximum_percentage: int = dataclasses.field(default=50)
choose_inactive: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\x19\xa9\x1b;') # 0x19a91b3b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'T\xa2\xd2\xb1') # 0x54a2d2b1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_percentage))
data.write(b'\xab\xbd\xd0G') # 0xabbdd047
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.percentage_chance))
data.write(b'\xf3\xfcnS') # 0xf3fc6e53
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.minimum_count))
data.write(b'\xd4G\tb') # 0xd4470962
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.maximum_count))
data.write(b'\xf5\x0b\x11\xeb') # 0xf50b11eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.minimum_percentage))
data.write(b'\xdcu\xec\xf3') # 0xdc75ecf3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.maximum_percentage))
data.write(b'C.\x9ds') # 0x432e9d73
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.choose_inactive))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
is_percentage=data['is_percentage'],
percentage_chance=data['percentage_chance'],
minimum_count=data['minimum_count'],
maximum_count=data['maximum_count'],
minimum_percentage=data['minimum_percentage'],
maximum_percentage=data['maximum_percentage'],
choose_inactive=data['choose_inactive'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'is_percentage': self.is_percentage,
'percentage_chance': self.percentage_chance,
'minimum_count': self.minimum_count,
'maximum_count': self.maximum_count,
'minimum_percentage': self.minimum_percentage,
'maximum_percentage': self.maximum_percentage,
'choose_inactive': self.choose_inactive,
}
_FAST_FORMAT = None
_FAST_IDS = (0x19a91b3b, 0x54a2d2b1, 0xabbdd047, 0xf3fc6e53, 0xd4470962, 0xf50b11eb, 0xdc75ecf3, 0x432e9d73)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct264]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHlLHlLHlLHlLHlLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(71))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct264(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_percentage_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_minimum_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_maximum_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_minimum_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_maximum_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_choose_inactive(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x19a91b3b: ('unknown', _decode_unknown),
0x54a2d2b1: ('is_percentage', _decode_is_percentage),
0xabbdd047: ('percentage_chance', _decode_percentage_chance),
0xf3fc6e53: ('minimum_count', _decode_minimum_count),
0xd4470962: ('maximum_count', _decode_maximum_count),
0xf50b11eb: ('minimum_percentage', _decode_minimum_percentage),
0xdc75ecf3: ('maximum_percentage', _decode_maximum_percentage),
0x432e9d73: ('choose_inactive', _decode_choose_inactive),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct264.py | 0.696371 | 0.270516 | UnknownStruct264.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct171(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
zoom: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
zoom_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xc8G\xc0') # 0x17c847c0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title_strings))
data.write(b'7\xfd\x19\x13') # 0x37fd1913
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction))
data.write(b'\xa1O4\xca') # 0xa14f34ca
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction_core))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'\xfaX\x1fg') # 0xfa581f67
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.zoom))
data.write(b'w:\x89\x12') # 0x773a8912
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.zoom_core))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title_strings=data['title_strings'],
instruction=data['instruction'],
instruction_core=data['instruction_core'],
back=data['back'],
back_core=data['back_core'],
zoom=data['zoom'],
zoom_core=data['zoom_core'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title_strings': self.title_strings,
'instruction': self.instruction,
'instruction_core': self.instruction_core,
'back': self.back,
'back_core': self.back_core,
'zoom': self.zoom,
'zoom_core': self.zoom_core,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_zoom(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_zoom_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0x17c847c0: ('title_strings', _decode_title_strings),
0x37fd1913: ('instruction', _decode_instruction),
0xa14f34ca: ('instruction_core', _decode_instruction_core),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0xfa581f67: ('zoom', _decode_zoom),
0x773a8912: ('zoom_core', _decode_zoom_core),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct171.py | 0.600305 | 0.201224 | UnknownStruct171.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerJumpHeights import PlayerJumpHeights
@dataclasses.dataclass()
class PlayerJumpData(BaseProperty):
normal_jump_heights: PlayerJumpHeights = dataclasses.field(default_factory=PlayerJumpHeights)
tar_inhibited_jump_heights: PlayerJumpHeights = dataclasses.field(default_factory=PlayerJumpHeights)
jump_tap_time: float = dataclasses.field(default=0.05000000074505806)
jump_pressed_early_maximum_time: float = dataclasses.field(default=0.12099999934434891)
jump_bump_into_wall_speed: float = dataclasses.field(default=3.0)
jump_crash_into_wall_speed: float = dataclasses.field(default=6.0)
jump_bump_into_ceiling_speed: float = dataclasses.field(default=3.0)
jump_crash_into_ceiling_speed: float = dataclasses.field(default=6.0)
jump_wall_hit_hang_time: float = dataclasses.field(default=0.10000000149011612)
jump_bump_into_wall_knockback_amount: float = dataclasses.field(default=0.25)
jump_bump_into_wall_knockback_time: float = dataclasses.field(default=0.25)
require_controller_input_for_jump_turns: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\x8b\xa1\xa2\x1a') # 0x8ba1a21a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal_jump_heights.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\x9ao\x1b') # 0x1c9a6f1b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tar_inhibited_jump_heights.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x*\x03\x10') # 0x782a0310
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_tap_time))
data.write(b'\xca\xae\xc6\x8e') # 0xcaaec68e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_pressed_early_maximum_time))
data.write(b'i\xe6V\x8d') # 0x69e6568d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_bump_into_wall_speed))
data.write(b'\x16\xa7\xfb\x91') # 0x16a7fb91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_crash_into_wall_speed))
data.write(b'\xe5p\xe6\xfe') # 0xe570e6fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_bump_into_ceiling_speed))
data.write(b'\xea>\x0f7') # 0xea3e0f37
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_crash_into_ceiling_speed))
data.write(b'Cl\xb2\xe7') # 0x436cb2e7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_wall_hit_hang_time))
data.write(b'\x9b\xa3\xf6q') # 0x9ba3f671
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_bump_into_wall_knockback_amount))
data.write(b'\x80\xfa\xa2\xf3') # 0x80faa2f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_bump_into_wall_knockback_time))
data.write(b'qb\xd6x') # 0x7162d678
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.require_controller_input_for_jump_turns))
@classmethod
def from_json(cls, data: dict):
return cls(
normal_jump_heights=PlayerJumpHeights.from_json(data['normal_jump_heights']),
tar_inhibited_jump_heights=PlayerJumpHeights.from_json(data['tar_inhibited_jump_heights']),
jump_tap_time=data['jump_tap_time'],
jump_pressed_early_maximum_time=data['jump_pressed_early_maximum_time'],
jump_bump_into_wall_speed=data['jump_bump_into_wall_speed'],
jump_crash_into_wall_speed=data['jump_crash_into_wall_speed'],
jump_bump_into_ceiling_speed=data['jump_bump_into_ceiling_speed'],
jump_crash_into_ceiling_speed=data['jump_crash_into_ceiling_speed'],
jump_wall_hit_hang_time=data['jump_wall_hit_hang_time'],
jump_bump_into_wall_knockback_amount=data['jump_bump_into_wall_knockback_amount'],
jump_bump_into_wall_knockback_time=data['jump_bump_into_wall_knockback_time'],
require_controller_input_for_jump_turns=data['require_controller_input_for_jump_turns'],
)
def to_json(self) -> dict:
return {
'normal_jump_heights': self.normal_jump_heights.to_json(),
'tar_inhibited_jump_heights': self.tar_inhibited_jump_heights.to_json(),
'jump_tap_time': self.jump_tap_time,
'jump_pressed_early_maximum_time': self.jump_pressed_early_maximum_time,
'jump_bump_into_wall_speed': self.jump_bump_into_wall_speed,
'jump_crash_into_wall_speed': self.jump_crash_into_wall_speed,
'jump_bump_into_ceiling_speed': self.jump_bump_into_ceiling_speed,
'jump_crash_into_ceiling_speed': self.jump_crash_into_ceiling_speed,
'jump_wall_hit_hang_time': self.jump_wall_hit_hang_time,
'jump_bump_into_wall_knockback_amount': self.jump_bump_into_wall_knockback_amount,
'jump_bump_into_wall_knockback_time': self.jump_bump_into_wall_knockback_time,
'require_controller_input_for_jump_turns': self.require_controller_input_for_jump_turns,
}
def _decode_normal_jump_heights(data: typing.BinaryIO, property_size: int):
return PlayerJumpHeights.from_stream(data, property_size)
def _decode_tar_inhibited_jump_heights(data: typing.BinaryIO, property_size: int):
return PlayerJumpHeights.from_stream(data, property_size)
def _decode_jump_tap_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_pressed_early_maximum_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_bump_into_wall_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_crash_into_wall_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_bump_into_ceiling_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_crash_into_ceiling_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_wall_hit_hang_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_bump_into_wall_knockback_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_bump_into_wall_knockback_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_require_controller_input_for_jump_turns(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8ba1a21a: ('normal_jump_heights', _decode_normal_jump_heights),
0x1c9a6f1b: ('tar_inhibited_jump_heights', _decode_tar_inhibited_jump_heights),
0x782a0310: ('jump_tap_time', _decode_jump_tap_time),
0xcaaec68e: ('jump_pressed_early_maximum_time', _decode_jump_pressed_early_maximum_time),
0x69e6568d: ('jump_bump_into_wall_speed', _decode_jump_bump_into_wall_speed),
0x16a7fb91: ('jump_crash_into_wall_speed', _decode_jump_crash_into_wall_speed),
0xe570e6fe: ('jump_bump_into_ceiling_speed', _decode_jump_bump_into_ceiling_speed),
0xea3e0f37: ('jump_crash_into_ceiling_speed', _decode_jump_crash_into_ceiling_speed),
0x436cb2e7: ('jump_wall_hit_hang_time', _decode_jump_wall_hit_hang_time),
0x9ba3f671: ('jump_bump_into_wall_knockback_amount', _decode_jump_bump_into_wall_knockback_amount),
0x80faa2f3: ('jump_bump_into_wall_knockback_time', _decode_jump_bump_into_wall_knockback_time),
0x7162d678: ('require_controller_input_for_jump_turns', _decode_require_controller_input_for_jump_turns),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerJumpData.py | 0.598077 | 0.36625 | PlayerJumpData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileBounceData import ProjectileBounceData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileCollisionData import ProjectileCollisionData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileData import ProjectileData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileMotionData import ProjectileMotionData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileRenderData import ProjectileRenderData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct205 import UnknownStruct205
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct206(BaseProperty):
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
projectile_data: ProjectileData = dataclasses.field(default_factory=ProjectileData)
projectile_render_data: ProjectileRenderData = dataclasses.field(default_factory=ProjectileRenderData)
projectile_collision_data: ProjectileCollisionData = dataclasses.field(default_factory=ProjectileCollisionData)
projectile_motion_data: ProjectileMotionData = dataclasses.field(default_factory=ProjectileMotionData)
can_bounce: bool = dataclasses.field(default=False)
projectile_bounce_data: ProjectileBounceData = dataclasses.field(default_factory=ProjectileBounceData)
scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_struct205: UnknownStruct205 = dataclasses.field(default_factory=UnknownStruct205)
unknown: float = dataclasses.field(default=2.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa5\xcc)\x82') # 0xa5cc2982
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd9\r\xab\t') # 0xd90dab09
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_render_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\xd9x_') # 0x58d9785f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_collision_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x90\xdc\xef\x98') # 0x90dcef98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_motion_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xccB\x84\xa2') # 0xcc4284a2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_bounce))
data.write(b'P\xa7\xe9K') # 0x50a7e94b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_bounce_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7&\xe5\xda') # 0xf726e5da
data.write(b'\x00\x0c') # size
self.scale.to_stream(data)
data.write(b'\xea\x0f\x13M') # 0xea0f134d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct205.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1\x80\xd4\xf3') # 0x3180d4f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
actor_information=ActorParameters.from_json(data['actor_information']),
projectile_data=ProjectileData.from_json(data['projectile_data']),
projectile_render_data=ProjectileRenderData.from_json(data['projectile_render_data']),
projectile_collision_data=ProjectileCollisionData.from_json(data['projectile_collision_data']),
projectile_motion_data=ProjectileMotionData.from_json(data['projectile_motion_data']),
can_bounce=data['can_bounce'],
projectile_bounce_data=ProjectileBounceData.from_json(data['projectile_bounce_data']),
scale=Vector.from_json(data['scale']),
unknown_struct205=UnknownStruct205.from_json(data['unknown_struct205']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'actor_information': self.actor_information.to_json(),
'projectile_data': self.projectile_data.to_json(),
'projectile_render_data': self.projectile_render_data.to_json(),
'projectile_collision_data': self.projectile_collision_data.to_json(),
'projectile_motion_data': self.projectile_motion_data.to_json(),
'can_bounce': self.can_bounce,
'projectile_bounce_data': self.projectile_bounce_data.to_json(),
'scale': self.scale.to_json(),
'unknown_struct205': self.unknown_struct205.to_json(),
'unknown': self.unknown,
}
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_projectile_data(data: typing.BinaryIO, property_size: int):
return ProjectileData.from_stream(data, property_size)
def _decode_projectile_render_data(data: typing.BinaryIO, property_size: int):
return ProjectileRenderData.from_stream(data, property_size)
def _decode_projectile_collision_data(data: typing.BinaryIO, property_size: int):
return ProjectileCollisionData.from_stream(data, property_size)
def _decode_projectile_motion_data(data: typing.BinaryIO, property_size: int):
return ProjectileMotionData.from_stream(data, property_size)
def _decode_can_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_projectile_bounce_data(data: typing.BinaryIO, property_size: int):
return ProjectileBounceData.from_stream(data, property_size)
def _decode_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_struct205(data: typing.BinaryIO, property_size: int):
return UnknownStruct205.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7e397fed: ('actor_information', _decode_actor_information),
0xa5cc2982: ('projectile_data', _decode_projectile_data),
0xd90dab09: ('projectile_render_data', _decode_projectile_render_data),
0x58d9785f: ('projectile_collision_data', _decode_projectile_collision_data),
0x90dcef98: ('projectile_motion_data', _decode_projectile_motion_data),
0xcc4284a2: ('can_bounce', _decode_can_bounce),
0x50a7e94b: ('projectile_bounce_data', _decode_projectile_bounce_data),
0xf726e5da: ('scale', _decode_scale),
0xea0f134d: ('unknown_struct205', _decode_unknown_struct205),
0x3180d4f3: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct206.py | 0.577972 | 0.316898 | UnknownStruct206.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class DespawnRules(BaseProperty):
can_despawn: bool = dataclasses.field(default=True)
respawn_after_death: bool = dataclasses.field(default=False)
wait_for_despawn_after_death: bool = dataclasses.field(default=True)
respawn_after_despawn: bool = dataclasses.field(default=True)
wait_for_despawn_after_child_despawn: bool = dataclasses.field(default=True)
spawns_on_screen: bool = dataclasses.field(default=False)
set_facing_on_respawn: bool = dataclasses.field(default=True)
respect_player_respawn_break: bool = dataclasses.field(default=False)
screen_planes: enums.ScreenPlanes = dataclasses.field(default=enums.ScreenPlanes.Unknown1)
despawn_timer: float = dataclasses.field(default=10.0)
despawn_distance: float = dataclasses.field(default=15.0)
far_despawn_distance: float = dataclasses.field(default=25.0)
activation_distance: float = dataclasses.field(default=5.0)
use_minimum_activation_distance: bool = dataclasses.field(default=False)
minimum_activation_distance: float = dataclasses.field(default=0.0)
respawn_after_despawn_delay: float = dataclasses.field(default=0.0)
use_player_activation_distance: bool = dataclasses.field(default=False)
player_activation_distance_squared: float = dataclasses.field(default=4.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x12') # 18 properties
data.write(b'\\\x9ay\x8c') # 0x5c9a798c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_despawn))
data.write(b'w\x86\x9av') # 0x77869a76
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.respawn_after_death))
data.write(b'z\xee\x0c\n') # 0x7aee0c0a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wait_for_despawn_after_death))
data.write(b'\xc2mtu') # 0xc26d7475
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.respawn_after_despawn))
data.write(b'\xe8\xbe\x10\xdc') # 0xe8be10dc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wait_for_despawn_after_child_despawn))
data.write(b'\x82iR\xe9') # 0x826952e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spawns_on_screen))
data.write(b'x\xba\xdf\xc1') # 0x78badfc1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.set_facing_on_respawn))
data.write(b'\x10\x0e\xbf:') # 0x100ebf3a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.respect_player_respawn_break))
data.write(b'\x06"I\xfb') # 0x62249fb
data.write(b'\x00\x04') # size
self.screen_planes.to_stream(data)
data.write(b'\xbc/\x0bA') # 0xbc2f0b41
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.despawn_timer))
data.write(b'\xe7eV(') # 0xe7655628
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.despawn_distance))
data.write(b'\xeb\xe0,\xd7') # 0xebe02cd7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_despawn_distance))
data.write(b'\xf9\nO\xe9') # 0xf90a4fe9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.activation_distance))
data.write(b'P\xc3\x16\x84') # 0x50c31684
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_minimum_activation_distance))
data.write(b'\xd6N\xff\x80') # 0xd64eff80
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_activation_distance))
data.write(b'\x17E\xdd&') # 0x1745dd26
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.respawn_after_despawn_delay))
data.write(b'j\x9a\xd7\xdf') # 0x6a9ad7df
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_player_activation_distance))
data.write(b'\xf5I_w') # 0xf5495f77
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_activation_distance_squared))
@classmethod
def from_json(cls, data: dict):
return cls(
can_despawn=data['can_despawn'],
respawn_after_death=data['respawn_after_death'],
wait_for_despawn_after_death=data['wait_for_despawn_after_death'],
respawn_after_despawn=data['respawn_after_despawn'],
wait_for_despawn_after_child_despawn=data['wait_for_despawn_after_child_despawn'],
spawns_on_screen=data['spawns_on_screen'],
set_facing_on_respawn=data['set_facing_on_respawn'],
respect_player_respawn_break=data['respect_player_respawn_break'],
screen_planes=enums.ScreenPlanes.from_json(data['screen_planes']),
despawn_timer=data['despawn_timer'],
despawn_distance=data['despawn_distance'],
far_despawn_distance=data['far_despawn_distance'],
activation_distance=data['activation_distance'],
use_minimum_activation_distance=data['use_minimum_activation_distance'],
minimum_activation_distance=data['minimum_activation_distance'],
respawn_after_despawn_delay=data['respawn_after_despawn_delay'],
use_player_activation_distance=data['use_player_activation_distance'],
player_activation_distance_squared=data['player_activation_distance_squared'],
)
def to_json(self) -> dict:
return {
'can_despawn': self.can_despawn,
'respawn_after_death': self.respawn_after_death,
'wait_for_despawn_after_death': self.wait_for_despawn_after_death,
'respawn_after_despawn': self.respawn_after_despawn,
'wait_for_despawn_after_child_despawn': self.wait_for_despawn_after_child_despawn,
'spawns_on_screen': self.spawns_on_screen,
'set_facing_on_respawn': self.set_facing_on_respawn,
'respect_player_respawn_break': self.respect_player_respawn_break,
'screen_planes': self.screen_planes.to_json(),
'despawn_timer': self.despawn_timer,
'despawn_distance': self.despawn_distance,
'far_despawn_distance': self.far_despawn_distance,
'activation_distance': self.activation_distance,
'use_minimum_activation_distance': self.use_minimum_activation_distance,
'minimum_activation_distance': self.minimum_activation_distance,
'respawn_after_despawn_delay': self.respawn_after_despawn_delay,
'use_player_activation_distance': self.use_player_activation_distance,
'player_activation_distance_squared': self.player_activation_distance_squared,
}
_FAST_FORMAT = None
_FAST_IDS = (0x5c9a798c, 0x77869a76, 0x7aee0c0a, 0xc26d7475, 0xe8be10dc, 0x826952e9, 0x78badfc1, 0x100ebf3a, 0x62249fb, 0xbc2f0b41, 0xe7655628, 0xebe02cd7, 0xf90a4fe9, 0x50c31684, 0xd64eff80, 0x1745dd26, 0x6a9ad7df, 0xf5495f77)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DespawnRules]:
if property_count != 18:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?LHLLHfLHfLHfLHfLH?LHfLHfLH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(150))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33], dec[36], dec[39], dec[42], dec[45], dec[48], dec[51]) != _FAST_IDS:
data.seek(before)
return None
return DespawnRules(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
enums.ScreenPlanes(dec[26]),
dec[29],
dec[32],
dec[35],
dec[38],
dec[41],
dec[44],
dec[47],
dec[50],
dec[53],
)
def _decode_can_despawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_respawn_after_death(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wait_for_despawn_after_death(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_respawn_after_despawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wait_for_despawn_after_child_despawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_spawns_on_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_set_facing_on_respawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_respect_player_respawn_break(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_screen_planes(data: typing.BinaryIO, property_size: int):
return enums.ScreenPlanes.from_stream(data)
def _decode_despawn_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_despawn_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_despawn_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_activation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_minimum_activation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_activation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_respawn_after_despawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_player_activation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player_activation_distance_squared(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5c9a798c: ('can_despawn', _decode_can_despawn),
0x77869a76: ('respawn_after_death', _decode_respawn_after_death),
0x7aee0c0a: ('wait_for_despawn_after_death', _decode_wait_for_despawn_after_death),
0xc26d7475: ('respawn_after_despawn', _decode_respawn_after_despawn),
0xe8be10dc: ('wait_for_despawn_after_child_despawn', _decode_wait_for_despawn_after_child_despawn),
0x826952e9: ('spawns_on_screen', _decode_spawns_on_screen),
0x78badfc1: ('set_facing_on_respawn', _decode_set_facing_on_respawn),
0x100ebf3a: ('respect_player_respawn_break', _decode_respect_player_respawn_break),
0x62249fb: ('screen_planes', _decode_screen_planes),
0xbc2f0b41: ('despawn_timer', _decode_despawn_timer),
0xe7655628: ('despawn_distance', _decode_despawn_distance),
0xebe02cd7: ('far_despawn_distance', _decode_far_despawn_distance),
0xf90a4fe9: ('activation_distance', _decode_activation_distance),
0x50c31684: ('use_minimum_activation_distance', _decode_use_minimum_activation_distance),
0xd64eff80: ('minimum_activation_distance', _decode_minimum_activation_distance),
0x1745dd26: ('respawn_after_despawn_delay', _decode_respawn_after_despawn_delay),
0x6a9ad7df: ('use_player_activation_distance', _decode_use_player_activation_distance),
0xf5495f77: ('player_activation_distance_squared', _decode_player_activation_distance_squared),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DespawnRules.py | 0.601008 | 0.304701 | DespawnRules.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class SpindlePositionInterpolant(BaseProperty):
interpolant_type: enums.InterpolantType = dataclasses.field(default=enums.InterpolantType.Unknown1)
interpolant_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'r=\xd1\x9c') # 0x723dd19c
data.write(b'\x00\x04') # size
self.interpolant_type.to_stream(data)
data.write(b'\x9aY\x8f\xa5') # 0x9a598fa5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.interpolant_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
interpolant_type=enums.InterpolantType.from_json(data['interpolant_type']),
interpolant_spline=Spline.from_json(data['interpolant_spline']),
)
def to_json(self) -> dict:
return {
'interpolant_type': self.interpolant_type.to_json(),
'interpolant_spline': self.interpolant_spline.to_json(),
}
def _decode_interpolant_type(data: typing.BinaryIO, property_size: int):
return enums.InterpolantType.from_stream(data)
def _decode_interpolant_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x723dd19c: ('interpolant_type', _decode_interpolant_type),
0x9a598fa5: ('interpolant_spline', _decode_interpolant_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SpindlePositionInterpolant.py | 0.595963 | 0.274336 | SpindlePositionInterpolant.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerRiseFromTheGraveData(BaseProperty):
rejoin_success_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rejoin_fail_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rejoin_fail_delay: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'V)\x95b') # 0x56299562
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rejoin_success_sound))
data.write(b'\x8d\x81o\x05') # 0x8d816f05
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rejoin_fail_sound))
data.write(b'<#0o') # 0x3c23306f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rejoin_fail_delay))
@classmethod
def from_json(cls, data: dict):
return cls(
rejoin_success_sound=data['rejoin_success_sound'],
rejoin_fail_sound=data['rejoin_fail_sound'],
rejoin_fail_delay=data['rejoin_fail_delay'],
)
def to_json(self) -> dict:
return {
'rejoin_success_sound': self.rejoin_success_sound,
'rejoin_fail_sound': self.rejoin_fail_sound,
'rejoin_fail_delay': self.rejoin_fail_delay,
}
_FAST_FORMAT = None
_FAST_IDS = (0x56299562, 0x8d816f05, 0x3c23306f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerRiseFromTheGraveData]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(38))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return PlayerRiseFromTheGraveData(
dec[2],
dec[5],
dec[8],
)
def _decode_rejoin_success_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rejoin_fail_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rejoin_fail_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x56299562: ('rejoin_success_sound', _decode_rejoin_success_sound),
0x8d816f05: ('rejoin_fail_sound', _decode_rejoin_fail_sound),
0x3c23306f: ('rejoin_fail_delay', _decode_rejoin_fail_delay),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerRiseFromTheGraveData.py | 0.589953 | 0.250615 | PlayerRiseFromTheGraveData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class DynamicLightIntensity(BaseProperty):
intensity: Spline = dataclasses.field(default_factory=Spline)
intensity_duration: float = dataclasses.field(default=0.0)
intensity_loops: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'#\x9d\r+') # 0x239d0d2b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.intensity.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9\r\x88\x99') # 0xc90d8899
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.intensity_duration))
data.write(b'\xaeg\xe0P') # 0xae67e050
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.intensity_loops))
@classmethod
def from_json(cls, data: dict):
return cls(
intensity=Spline.from_json(data['intensity']),
intensity_duration=data['intensity_duration'],
intensity_loops=data['intensity_loops'],
)
def to_json(self) -> dict:
return {
'intensity': self.intensity.to_json(),
'intensity_duration': self.intensity_duration,
'intensity_loops': self.intensity_loops,
}
def _decode_intensity(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_intensity_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_intensity_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x239d0d2b: ('intensity', _decode_intensity),
0xc90d8899: ('intensity_duration', _decode_intensity_duration),
0xae67e050: ('intensity_loops', _decode_intensity_loops),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DynamicLightIntensity.py | 0.738198 | 0.3213 | DynamicLightIntensity.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class PlayerMountData(BaseProperty):
unknown_0x2b70fd04: int = dataclasses.field(default=0)
unknown_0x138bac93: int = dataclasses.field(default=0)
can_mount_rider: bool = dataclasses.field(default=False)
can_dismount_rider: bool = dataclasses.field(default=False)
rider_must_be_falling: bool = dataclasses.field(default=True)
rider_must_be_above_mount: bool = dataclasses.field(default=True)
slaves_can_trigger_mount: bool = dataclasses.field(default=False)
mount_radius: float = dataclasses.field(default=1.100000023841858)
mount_lerp_speed: float = dataclasses.field(default=15.0)
dismount_disable_time: float = dataclasses.field(default=1.0)
dismount_riders_on_death_fall: bool = dataclasses.field(default=True)
allow_struggle_interaction: bool = dataclasses.field(default=False)
should_riders_interact_with_triggers: bool = dataclasses.field(default=False)
riders_handle_their_own_contact: bool = dataclasses.field(default=False)
disallow_recently_grab_detached: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'+p\xfd\x04') # 0x2b70fd04
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2b70fd04))
data.write(b'\x13\x8b\xac\x93') # 0x138bac93
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x138bac93))
data.write(b'\xdd\x96\xe9\x15') # 0xdd96e915
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_mount_rider))
data.write(b'\xe5\xfc\xd8\xdb') # 0xe5fcd8db
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_dismount_rider))
data.write(b'\x16\xa4\xba"') # 0x16a4ba22
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rider_must_be_falling))
data.write(b'\x1e\x1d\x08\xf4') # 0x1e1d08f4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rider_must_be_above_mount))
data.write(b'Bi\x80\xfc') # 0x426980fc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.slaves_can_trigger_mount))
data.write(b's\xee~\xc2') # 0x73ee7ec2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mount_radius))
data.write(b'z\xbdUm') # 0x7abd556d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mount_lerp_speed))
data.write(b'\x15\xe67\x83') # 0x15e63783
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dismount_disable_time))
data.write(b'\x1aQ\x89(') # 0x1a518928
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.dismount_riders_on_death_fall))
data.write(b'\xdb\xd1\xe3\xbf') # 0xdbd1e3bf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_struggle_interaction))
data.write(b'O\xa9r\xd1') # 0x4fa972d1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.should_riders_interact_with_triggers))
data.write(b'Ky\xdb\xa9') # 0x4b79dba9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.riders_handle_their_own_contact))
data.write(b'\xf9\x8e\xb3l') # 0xf98eb36c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disallow_recently_grab_detached))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x2b70fd04=data['unknown_0x2b70fd04'],
unknown_0x138bac93=data['unknown_0x138bac93'],
can_mount_rider=data['can_mount_rider'],
can_dismount_rider=data['can_dismount_rider'],
rider_must_be_falling=data['rider_must_be_falling'],
rider_must_be_above_mount=data['rider_must_be_above_mount'],
slaves_can_trigger_mount=data['slaves_can_trigger_mount'],
mount_radius=data['mount_radius'],
mount_lerp_speed=data['mount_lerp_speed'],
dismount_disable_time=data['dismount_disable_time'],
dismount_riders_on_death_fall=data['dismount_riders_on_death_fall'],
allow_struggle_interaction=data['allow_struggle_interaction'],
should_riders_interact_with_triggers=data['should_riders_interact_with_triggers'],
riders_handle_their_own_contact=data['riders_handle_their_own_contact'],
disallow_recently_grab_detached=data['disallow_recently_grab_detached'],
)
def to_json(self) -> dict:
return {
'unknown_0x2b70fd04': self.unknown_0x2b70fd04,
'unknown_0x138bac93': self.unknown_0x138bac93,
'can_mount_rider': self.can_mount_rider,
'can_dismount_rider': self.can_dismount_rider,
'rider_must_be_falling': self.rider_must_be_falling,
'rider_must_be_above_mount': self.rider_must_be_above_mount,
'slaves_can_trigger_mount': self.slaves_can_trigger_mount,
'mount_radius': self.mount_radius,
'mount_lerp_speed': self.mount_lerp_speed,
'dismount_disable_time': self.dismount_disable_time,
'dismount_riders_on_death_fall': self.dismount_riders_on_death_fall,
'allow_struggle_interaction': self.allow_struggle_interaction,
'should_riders_interact_with_triggers': self.should_riders_interact_with_triggers,
'riders_handle_their_own_contact': self.riders_handle_their_own_contact,
'disallow_recently_grab_detached': self.disallow_recently_grab_detached,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2b70fd04, 0x138bac93, 0xdd96e915, 0xe5fcd8db, 0x16a4ba22, 0x1e1d08f4, 0x426980fc, 0x73ee7ec2, 0x7abd556d, 0x15e63783, 0x1a518928, 0xdbd1e3bf, 0x4fa972d1, 0x4b79dba9, 0xf98eb36c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerMountData]:
if property_count != 15:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLH?LH?LH?LH?LH?LHfLHfLHfLH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(120))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33], dec[36], dec[39], dec[42]) != _FAST_IDS:
data.seek(before)
return None
return PlayerMountData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
dec[38],
dec[41],
dec[44],
)
def _decode_unknown_0x2b70fd04(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x138bac93(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_can_mount_rider(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_dismount_rider(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rider_must_be_falling(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rider_must_be_above_mount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_slaves_can_trigger_mount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_mount_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mount_lerp_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dismount_disable_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dismount_riders_on_death_fall(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_struggle_interaction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_should_riders_interact_with_triggers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_riders_handle_their_own_contact(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disallow_recently_grab_detached(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2b70fd04: ('unknown_0x2b70fd04', _decode_unknown_0x2b70fd04),
0x138bac93: ('unknown_0x138bac93', _decode_unknown_0x138bac93),
0xdd96e915: ('can_mount_rider', _decode_can_mount_rider),
0xe5fcd8db: ('can_dismount_rider', _decode_can_dismount_rider),
0x16a4ba22: ('rider_must_be_falling', _decode_rider_must_be_falling),
0x1e1d08f4: ('rider_must_be_above_mount', _decode_rider_must_be_above_mount),
0x426980fc: ('slaves_can_trigger_mount', _decode_slaves_can_trigger_mount),
0x73ee7ec2: ('mount_radius', _decode_mount_radius),
0x7abd556d: ('mount_lerp_speed', _decode_mount_lerp_speed),
0x15e63783: ('dismount_disable_time', _decode_dismount_disable_time),
0x1a518928: ('dismount_riders_on_death_fall', _decode_dismount_riders_on_death_fall),
0xdbd1e3bf: ('allow_struggle_interaction', _decode_allow_struggle_interaction),
0x4fa972d1: ('should_riders_interact_with_triggers', _decode_should_riders_interact_with_triggers),
0x4b79dba9: ('riders_handle_their_own_contact', _decode_riders_handle_their_own_contact),
0xf98eb36c: ('disallow_recently_grab_detached', _decode_disallow_recently_grab_detached),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMountData.py | 0.568536 | 0.312475 | PlayerMountData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct62(BaseProperty):
time: float = dataclasses.field(default=2.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
@classmethod
def from_json(cls, data: dict):
return cls(
time=data['time'],
)
def to_json(self) -> dict:
return {
'time': self.time,
}
_FAST_FORMAT = None
_FAST_IDS = (0x44335aff)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct62]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct62(
dec[2],
)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x44335aff: ('time', _decode_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct62.py | 0.636579 | 0.314564 | UnknownStruct62.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class UnknownStruct60(BaseProperty):
swoop_direction: enums.SwoopDirection = dataclasses.field(default=enums.SwoopDirection.Unknown1)
type: enums.UnknownEnum4 = dataclasses.field(default=enums.UnknownEnum4.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x13\xd7\x0bg') # 0x13d70b67
data.write(b'\x00\x04') # size
self.swoop_direction.to_stream(data)
data.write(b'GK\xcc\xe3') # 0x474bcce3
data.write(b'\x00\x04') # size
self.type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
swoop_direction=enums.SwoopDirection.from_json(data['swoop_direction']),
type=enums.UnknownEnum4.from_json(data['type']),
)
def to_json(self) -> dict:
return {
'swoop_direction': self.swoop_direction.to_json(),
'type': self.type.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x13d70b67, 0x474bcce3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct60]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct60(
enums.SwoopDirection(dec[2]),
enums.UnknownEnum4(dec[5]),
)
def _decode_swoop_direction(data: typing.BinaryIO, property_size: int):
return enums.SwoopDirection.from_stream(data)
def _decode_type(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum4.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x13d70b67: ('swoop_direction', _decode_swoop_direction),
0x474bcce3: ('type', _decode_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct60.py | 0.662796 | 0.306585 | UnknownStruct60.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct28 import UnknownStruct28
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct181(BaseProperty):
hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
unknown_struct28_0x67a7c770: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct28_0xc68bc9ec: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_0x9be6a5d6: float = dataclasses.field(default=5.0)
comment_delay: float = dataclasses.field(default=10.0)
comment_duration: float = dataclasses.field(default=10.0)
unknown_0xf34d7c81: int = dataclasses.field(default=3)
input_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0xabc01c18: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
first_entry_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
first_exit_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
generic_entry_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
generic_exit_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x7f2a409c: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
failed_key_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
failed_capacity_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
coin_icon_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
exit_confirm: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
select: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD', 'STRG']}, default=default_asset_id)
select_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
return_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x9c31d707: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x17') # 23 properties
data.write(b'\xf2)\x9e\xd6') # 0xf2299ed6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_frame))
data.write(b's\xe2\x81\x9b') # 0x73e2819b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'g\xa7\xc7p') # 0x67a7c770
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0x67a7c770.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\x8b\xc9\xec') # 0xc68bc9ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0xc68bc9ec.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9b\xe6\xa5\xd6') # 0x9be6a5d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9be6a5d6))
data.write(b'\x9e\xbe\x81-') # 0x9ebe812d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.comment_delay))
data.write(b'S\x1f\x1c\xe0') # 0x531f1ce0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.comment_duration))
data.write(b'\xf3M|\x81') # 0xf34d7c81
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xf34d7c81))
data.write(b' \x0e\xbc^') # 0x200ebc5e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.input_string))
data.write(b'\xab\xc0\x1c\x18') # 0xabc01c18
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0xabc01c18))
data.write(b'=\xaf;j') # 0x3daf3b6a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.first_entry_string))
data.write(b'\x8fa\xa2U') # 0x8f61a255
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.first_exit_string))
data.write(b'\xc2_.\x19') # 0xc25f2e19
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.generic_entry_strings))
data.write(b'p\xcc\xa1-') # 0x70cca12d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.generic_exit_strings))
data.write(b'\x7f*@\x9c') # 0x7f2a409c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x7f2a409c))
data.write(b'.\xb4\xa9\r') # 0x2eb4a90d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.failed_key_string))
data.write(b'\x89\x1at\x1f') # 0x891a741f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.failed_capacity_string))
data.write(b'p\xa2\x85T') # 0x70a28554
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.coin_icon_string))
data.write(b'vB\xefR') # 0x7642ef52
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.exit_confirm))
data.write(b'\x8e\xd6R\x83') # 0x8ed65283
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select))
data.write(b'\xa4\rA\x0e') # 0xa40d410e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_core))
data.write(b'\x95\x85\xb5\x87') # 0x9585b587
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.return_text))
data.write(b'\x9c1\xd7\x07') # 0x9c31d707
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x9c31d707))
@classmethod
def from_json(cls, data: dict):
return cls(
hud_frame=data['hud_frame'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
unknown_struct28_0x67a7c770=UnknownStruct28.from_json(data['unknown_struct28_0x67a7c770']),
unknown_struct28_0xc68bc9ec=UnknownStruct28.from_json(data['unknown_struct28_0xc68bc9ec']),
unknown_0x9be6a5d6=data['unknown_0x9be6a5d6'],
comment_delay=data['comment_delay'],
comment_duration=data['comment_duration'],
unknown_0xf34d7c81=data['unknown_0xf34d7c81'],
input_string=data['input_string'],
strg_0xabc01c18=data['strg_0xabc01c18'],
first_entry_string=data['first_entry_string'],
first_exit_string=data['first_exit_string'],
generic_entry_strings=data['generic_entry_strings'],
generic_exit_strings=data['generic_exit_strings'],
strg_0x7f2a409c=data['strg_0x7f2a409c'],
failed_key_string=data['failed_key_string'],
failed_capacity_string=data['failed_capacity_string'],
coin_icon_string=data['coin_icon_string'],
exit_confirm=data['exit_confirm'],
select=data['select'],
select_core=data['select_core'],
return_text=data['return_text'],
strg_0x9c31d707=data['strg_0x9c31d707'],
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'unknown_struct28_0x67a7c770': self.unknown_struct28_0x67a7c770.to_json(),
'unknown_struct28_0xc68bc9ec': self.unknown_struct28_0xc68bc9ec.to_json(),
'unknown_0x9be6a5d6': self.unknown_0x9be6a5d6,
'comment_delay': self.comment_delay,
'comment_duration': self.comment_duration,
'unknown_0xf34d7c81': self.unknown_0xf34d7c81,
'input_string': self.input_string,
'strg_0xabc01c18': self.strg_0xabc01c18,
'first_entry_string': self.first_entry_string,
'first_exit_string': self.first_exit_string,
'generic_entry_strings': self.generic_entry_strings,
'generic_exit_strings': self.generic_exit_strings,
'strg_0x7f2a409c': self.strg_0x7f2a409c,
'failed_key_string': self.failed_key_string,
'failed_capacity_string': self.failed_capacity_string,
'coin_icon_string': self.coin_icon_string,
'exit_confirm': self.exit_confirm,
'select': self.select,
'select_core': self.select_core,
'return_text': self.return_text,
'strg_0x9c31d707': self.strg_0x9c31d707,
}
def _decode_hud_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_unknown_struct28_0x67a7c770(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct28_0xc68bc9ec(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_0x9be6a5d6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_comment_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_comment_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf34d7c81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_input_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0xabc01c18(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_first_entry_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_first_exit_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_generic_entry_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_generic_exit_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x7f2a409c(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_failed_key_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_failed_capacity_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_coin_icon_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_exit_confirm(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_return_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x9c31d707(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf2299ed6: ('hud_frame', _decode_hud_frame),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0x67a7c770: ('unknown_struct28_0x67a7c770', _decode_unknown_struct28_0x67a7c770),
0xc68bc9ec: ('unknown_struct28_0xc68bc9ec', _decode_unknown_struct28_0xc68bc9ec),
0x9be6a5d6: ('unknown_0x9be6a5d6', _decode_unknown_0x9be6a5d6),
0x9ebe812d: ('comment_delay', _decode_comment_delay),
0x531f1ce0: ('comment_duration', _decode_comment_duration),
0xf34d7c81: ('unknown_0xf34d7c81', _decode_unknown_0xf34d7c81),
0x200ebc5e: ('input_string', _decode_input_string),
0xabc01c18: ('strg_0xabc01c18', _decode_strg_0xabc01c18),
0x3daf3b6a: ('first_entry_string', _decode_first_entry_string),
0x8f61a255: ('first_exit_string', _decode_first_exit_string),
0xc25f2e19: ('generic_entry_strings', _decode_generic_entry_strings),
0x70cca12d: ('generic_exit_strings', _decode_generic_exit_strings),
0x7f2a409c: ('strg_0x7f2a409c', _decode_strg_0x7f2a409c),
0x2eb4a90d: ('failed_key_string', _decode_failed_key_string),
0x891a741f: ('failed_capacity_string', _decode_failed_capacity_string),
0x70a28554: ('coin_icon_string', _decode_coin_icon_string),
0x7642ef52: ('exit_confirm', _decode_exit_confirm),
0x8ed65283: ('select', _decode_select),
0xa40d410e: ('select_core', _decode_select_core),
0x9585b587: ('return_text', _decode_return_text),
0x9c31d707: ('strg_0x9c31d707', _decode_strg_0x9c31d707),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct181.py | 0.489259 | 0.156685 | UnknownStruct181.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.JungleBossStructB import JungleBossStructB
@dataclasses.dataclass()
class UnknownStruct202(BaseProperty):
unknown_0x28ca1360: bool = dataclasses.field(default=False)
unknown_0x775a0160: str = dataclasses.field(default='')
unknown_0x06efdab2: int = dataclasses.field(default=0)
jungle_boss_struct_b_0xd4292680: JungleBossStructB = dataclasses.field(default_factory=JungleBossStructB)
jungle_boss_struct_b_0x90880398: JungleBossStructB = dataclasses.field(default_factory=JungleBossStructB)
jungle_boss_struct_b_0xace8e090: JungleBossStructB = dataclasses.field(default_factory=JungleBossStructB)
jungle_boss_struct_b_0x19ca49a8: JungleBossStructB = dataclasses.field(default_factory=JungleBossStructB)
jungle_boss_struct_b_0x25aaaaa0: JungleBossStructB = dataclasses.field(default_factory=JungleBossStructB)
jungle_boss_struct_b_0x610b8fb8: JungleBossStructB = dataclasses.field(default_factory=JungleBossStructB)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'(\xca\x13`') # 0x28ca1360
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x28ca1360))
data.write(b'wZ\x01`') # 0x775a0160
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x775a0160.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x06\xef\xda\xb2') # 0x6efdab2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x06efdab2))
data.write(b'\xd4)&\x80') # 0xd4292680
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_b_0xd4292680.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x90\x88\x03\x98') # 0x90880398
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_b_0x90880398.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xac\xe8\xe0\x90') # 0xace8e090
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_b_0xace8e090.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\xcaI\xa8') # 0x19ca49a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_b_0x19ca49a8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%\xaa\xaa\xa0') # 0x25aaaaa0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_b_0x25aaaaa0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\x0b\x8f\xb8') # 0x610b8fb8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_b_0x610b8fb8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x28ca1360=data['unknown_0x28ca1360'],
unknown_0x775a0160=data['unknown_0x775a0160'],
unknown_0x06efdab2=data['unknown_0x06efdab2'],
jungle_boss_struct_b_0xd4292680=JungleBossStructB.from_json(data['jungle_boss_struct_b_0xd4292680']),
jungle_boss_struct_b_0x90880398=JungleBossStructB.from_json(data['jungle_boss_struct_b_0x90880398']),
jungle_boss_struct_b_0xace8e090=JungleBossStructB.from_json(data['jungle_boss_struct_b_0xace8e090']),
jungle_boss_struct_b_0x19ca49a8=JungleBossStructB.from_json(data['jungle_boss_struct_b_0x19ca49a8']),
jungle_boss_struct_b_0x25aaaaa0=JungleBossStructB.from_json(data['jungle_boss_struct_b_0x25aaaaa0']),
jungle_boss_struct_b_0x610b8fb8=JungleBossStructB.from_json(data['jungle_boss_struct_b_0x610b8fb8']),
)
def to_json(self) -> dict:
return {
'unknown_0x28ca1360': self.unknown_0x28ca1360,
'unknown_0x775a0160': self.unknown_0x775a0160,
'unknown_0x06efdab2': self.unknown_0x06efdab2,
'jungle_boss_struct_b_0xd4292680': self.jungle_boss_struct_b_0xd4292680.to_json(),
'jungle_boss_struct_b_0x90880398': self.jungle_boss_struct_b_0x90880398.to_json(),
'jungle_boss_struct_b_0xace8e090': self.jungle_boss_struct_b_0xace8e090.to_json(),
'jungle_boss_struct_b_0x19ca49a8': self.jungle_boss_struct_b_0x19ca49a8.to_json(),
'jungle_boss_struct_b_0x25aaaaa0': self.jungle_boss_struct_b_0x25aaaaa0.to_json(),
'jungle_boss_struct_b_0x610b8fb8': self.jungle_boss_struct_b_0x610b8fb8.to_json(),
}
def _decode_unknown_0x28ca1360(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x775a0160(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x06efdab2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_jungle_boss_struct_b_0xd4292680(data: typing.BinaryIO, property_size: int):
return JungleBossStructB.from_stream(data, property_size)
def _decode_jungle_boss_struct_b_0x90880398(data: typing.BinaryIO, property_size: int):
return JungleBossStructB.from_stream(data, property_size)
def _decode_jungle_boss_struct_b_0xace8e090(data: typing.BinaryIO, property_size: int):
return JungleBossStructB.from_stream(data, property_size)
def _decode_jungle_boss_struct_b_0x19ca49a8(data: typing.BinaryIO, property_size: int):
return JungleBossStructB.from_stream(data, property_size)
def _decode_jungle_boss_struct_b_0x25aaaaa0(data: typing.BinaryIO, property_size: int):
return JungleBossStructB.from_stream(data, property_size)
def _decode_jungle_boss_struct_b_0x610b8fb8(data: typing.BinaryIO, property_size: int):
return JungleBossStructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x28ca1360: ('unknown_0x28ca1360', _decode_unknown_0x28ca1360),
0x775a0160: ('unknown_0x775a0160', _decode_unknown_0x775a0160),
0x6efdab2: ('unknown_0x06efdab2', _decode_unknown_0x06efdab2),
0xd4292680: ('jungle_boss_struct_b_0xd4292680', _decode_jungle_boss_struct_b_0xd4292680),
0x90880398: ('jungle_boss_struct_b_0x90880398', _decode_jungle_boss_struct_b_0x90880398),
0xace8e090: ('jungle_boss_struct_b_0xace8e090', _decode_jungle_boss_struct_b_0xace8e090),
0x19ca49a8: ('jungle_boss_struct_b_0x19ca49a8', _decode_jungle_boss_struct_b_0x19ca49a8),
0x25aaaaa0: ('jungle_boss_struct_b_0x25aaaaa0', _decode_jungle_boss_struct_b_0x25aaaaa0),
0x610b8fb8: ('jungle_boss_struct_b_0x610b8fb8', _decode_jungle_boss_struct_b_0x610b8fb8),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct202.py | 0.500977 | 0.33887 | UnknownStruct202.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.OffsetPosition import OffsetPosition
from retro_data_structures.properties.dkc_returns.archetypes.PathPosition import PathPosition
from retro_data_structures.properties.dkc_returns.archetypes.SpindlePosition import SpindlePosition
from retro_data_structures.properties.dkc_returns.archetypes.SurfacePosition import SurfacePosition
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct73 import UnknownStruct73
@dataclasses.dataclass()
class CameraPosition(BaseProperty):
position_type: enums.PositionType = dataclasses.field(default=enums.PositionType.Unknown2)
flags_camera_position: int = dataclasses.field(default=2) # Flagset
path: PathPosition = dataclasses.field(default_factory=PathPosition)
spindle: SpindlePosition = dataclasses.field(default_factory=SpindlePosition)
surface: SurfacePosition = dataclasses.field(default_factory=SurfacePosition)
offset: OffsetPosition = dataclasses.field(default_factory=OffsetPosition)
unknown_struct73: UnknownStruct73 = dataclasses.field(default_factory=UnknownStruct73)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xb7\xcdG\x10') # 0xb7cd4710
data.write(b'\x00\x04') # size
self.position_type.to_stream(data)
data.write(b'\xb1\xb6\xcf3') # 0xb1b6cf33
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_camera_position))
data.write(b'\xe8\xab\x9b\xc8') # 0xe8ab9bc8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9e\xc1\xdf\x0c') # 0x9ec1df0c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbb\xb2\xd1\xe6') # 0xbbb2d1e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surface.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x07\xd1\x94\xaf') # 0x7d194af
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xbf\x81\xd7') # 0xebbf81d7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct73.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
position_type=enums.PositionType.from_json(data['position_type']),
flags_camera_position=data['flags_camera_position'],
path=PathPosition.from_json(data['path']),
spindle=SpindlePosition.from_json(data['spindle']),
surface=SurfacePosition.from_json(data['surface']),
offset=OffsetPosition.from_json(data['offset']),
unknown_struct73=UnknownStruct73.from_json(data['unknown_struct73']),
)
def to_json(self) -> dict:
return {
'position_type': self.position_type.to_json(),
'flags_camera_position': self.flags_camera_position,
'path': self.path.to_json(),
'spindle': self.spindle.to_json(),
'surface': self.surface.to_json(),
'offset': self.offset.to_json(),
'unknown_struct73': self.unknown_struct73.to_json(),
}
def _decode_position_type(data: typing.BinaryIO, property_size: int):
return enums.PositionType.from_stream(data)
def _decode_flags_camera_position(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_path(data: typing.BinaryIO, property_size: int):
return PathPosition.from_stream(data, property_size)
def _decode_spindle(data: typing.BinaryIO, property_size: int):
return SpindlePosition.from_stream(data, property_size)
def _decode_surface(data: typing.BinaryIO, property_size: int):
return SurfacePosition.from_stream(data, property_size)
def _decode_offset(data: typing.BinaryIO, property_size: int):
return OffsetPosition.from_stream(data, property_size)
def _decode_unknown_struct73(data: typing.BinaryIO, property_size: int):
return UnknownStruct73.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb7cd4710: ('position_type', _decode_position_type),
0xb1b6cf33: ('flags_camera_position', _decode_flags_camera_position),
0xe8ab9bc8: ('path', _decode_path),
0x9ec1df0c: ('spindle', _decode_spindle),
0xbbb2d1e6: ('surface', _decode_surface),
0x7d194af: ('offset', _decode_offset),
0xebbf81d7: ('unknown_struct73', _decode_unknown_struct73),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraPosition.py | 0.658418 | 0.314748 | CameraPosition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class CameraShakerEnvelope(BaseProperty):
shake_shape: enums.ShakeShape = dataclasses.field(default=enums.ShakeShape.Unknown1)
amplitude: Spline = dataclasses.field(default_factory=Spline)
period: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xc6\x08\x9a?') # 0xc6089a3f
data.write(b'\x00\x04') # size
self.shake_shape.to_stream(data)
data.write(b'\x90\xb3\xcc~') # 0x90b3cc7e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.amplitude.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'i\xa8\x15\x17') # 0x69a81517
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.period.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
shake_shape=enums.ShakeShape.from_json(data['shake_shape']),
amplitude=Spline.from_json(data['amplitude']),
period=Spline.from_json(data['period']),
)
def to_json(self) -> dict:
return {
'shake_shape': self.shake_shape.to_json(),
'amplitude': self.amplitude.to_json(),
'period': self.period.to_json(),
}
def _decode_shake_shape(data: typing.BinaryIO, property_size: int):
return enums.ShakeShape.from_stream(data)
def _decode_amplitude(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_period(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc6089a3f: ('shake_shape', _decode_shake_shape),
0x90b3cc7e: ('amplitude', _decode_amplitude),
0x69a81517: ('period', _decode_period),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraShakerEnvelope.py | 0.672762 | 0.327252 | CameraShakerEnvelope.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct227(BaseProperty):
box_min_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
box_max_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x1c\xa9\x85\xde') # 0x1ca985de
data.write(b'\x00\x0c') # size
self.box_min_offset.to_stream(data)
data.write(b';\x12\xe2\xef') # 0x3b12e2ef
data.write(b'\x00\x0c') # size
self.box_max_offset.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
box_min_offset=Vector.from_json(data['box_min_offset']),
box_max_offset=Vector.from_json(data['box_max_offset']),
)
def to_json(self) -> dict:
return {
'box_min_offset': self.box_min_offset.to_json(),
'box_max_offset': self.box_max_offset.to_json(),
}
def _decode_box_min_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_box_max_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1ca985de: ('box_min_offset', _decode_box_min_offset),
0x3b12e2ef: ('box_max_offset', _decode_box_max_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct227.py | 0.724286 | 0.333978 | UnknownStruct227.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class UnknownStruct11(BaseProperty):
unknown_0xf060eeec: int = dataclasses.field(default=3301645737) # Choice
unknown_0x3dd7b303: float = dataclasses.field(default=0.0)
pre_delay_time: float = dataclasses.field(default=0.0)
fused_mode: enums.FusedMode = dataclasses.field(default=enums.FusedMode.Unknown1)
fused_time: float = dataclasses.field(default=0.009999999776482582)
coloration: float = dataclasses.field(default=0.0)
damping: float = dataclasses.field(default=0.0)
cross_talk: float = dataclasses.field(default=0.0)
early_gain: float = dataclasses.field(default=0.0)
fused_gain: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\xf0`\xee\xec') # 0xf060eeec
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0xf060eeec))
data.write(b'=\xd7\xb3\x03') # 0x3dd7b303
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3dd7b303))
data.write(b'\xf5*\xf9\xf3') # 0xf52af9f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pre_delay_time))
data.write(b'"\xa0\x05\x8d') # 0x22a0058d
data.write(b'\x00\x04') # size
self.fused_mode.to_stream(data)
data.write(b'\xc7z\x892') # 0xc77a8932
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fused_time))
data.write(b']k\x10\x84') # 0x5d6b1084
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.coloration))
data.write(b'\xfc\xf4\xaa\xb0') # 0xfcf4aab0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damping))
data.write(b'\xfb\x11\xa4\x12') # 0xfb11a412
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cross_talk))
data.write(b'%=\xa9\xc6') # 0x253da9c6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.early_gain))
data.write(b'\x1fZ8\xe3') # 0x1f5a38e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fused_gain))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xf060eeec=data['unknown_0xf060eeec'],
unknown_0x3dd7b303=data['unknown_0x3dd7b303'],
pre_delay_time=data['pre_delay_time'],
fused_mode=enums.FusedMode.from_json(data['fused_mode']),
fused_time=data['fused_time'],
coloration=data['coloration'],
damping=data['damping'],
cross_talk=data['cross_talk'],
early_gain=data['early_gain'],
fused_gain=data['fused_gain'],
)
def to_json(self) -> dict:
return {
'unknown_0xf060eeec': self.unknown_0xf060eeec,
'unknown_0x3dd7b303': self.unknown_0x3dd7b303,
'pre_delay_time': self.pre_delay_time,
'fused_mode': self.fused_mode.to_json(),
'fused_time': self.fused_time,
'coloration': self.coloration,
'damping': self.damping,
'cross_talk': self.cross_talk,
'early_gain': self.early_gain,
'fused_gain': self.fused_gain,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf060eeec, 0x3dd7b303, 0xf52af9f3, 0x22a0058d, 0xc77a8932, 0x5d6b1084, 0xfcf4aab0, 0xfb11a412, 0x253da9c6, 0x1f5a38e3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct11]:
if property_count != 10:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHLLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(100))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct11(
dec[2],
dec[5],
dec[8],
enums.FusedMode(dec[11]),
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
)
def _decode_unknown_0xf060eeec(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x3dd7b303(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pre_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fused_mode(data: typing.BinaryIO, property_size: int):
return enums.FusedMode.from_stream(data)
def _decode_fused_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_coloration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damping(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cross_talk(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_early_gain(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fused_gain(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf060eeec: ('unknown_0xf060eeec', _decode_unknown_0xf060eeec),
0x3dd7b303: ('unknown_0x3dd7b303', _decode_unknown_0x3dd7b303),
0xf52af9f3: ('pre_delay_time', _decode_pre_delay_time),
0x22a0058d: ('fused_mode', _decode_fused_mode),
0xc77a8932: ('fused_time', _decode_fused_time),
0x5d6b1084: ('coloration', _decode_coloration),
0xfcf4aab0: ('damping', _decode_damping),
0xfb11a412: ('cross_talk', _decode_cross_talk),
0x253da9c6: ('early_gain', _decode_early_gain),
0x1f5a38e3: ('fused_gain', _decode_fused_gain),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct11.py | 0.620622 | 0.262171 | UnknownStruct11.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerAttackBounceData import PlayerAttackBounceData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class KongRunningSlapData(BaseProperty):
running_slap_box_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=30.0, y=30.0, z=30.0))
delay_jumping_after_running_slap: float = dataclasses.field(default=0.25)
roll_controller_motion_detection_time: float = dataclasses.field(default=0.125)
jump_from_roll_control_scalar: float = dataclasses.field(default=2.0)
minimum_jump_height: float = dataclasses.field(default=2.0)
maximum_jump_height: float = dataclasses.field(default=4.599999904632568)
attack_bounce_data: PlayerAttackBounceData = dataclasses.field(default_factory=PlayerAttackBounceData)
min_horizontal_controller_movement_to_trigger_running_slap: float = dataclasses.field(default=0.5)
min_speed_to_trigger_running_slap: float = dataclasses.field(default=6.0)
speed_multiplier: float = dataclasses.field(default=1.5)
roll_duration: float = dataclasses.field(default=1.0)
disallow_turn_duration: float = dataclasses.field(default=0.10000000149011612)
roll_slap_duration: float = dataclasses.field(default=0.5)
delay_between_rolls: float = dataclasses.field(default=0.4000000059604645)
roll_attack_damage_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0f') # 15 properties
data.write(b'F2"\x87') # 0x46322287
data.write(b'\x00\x0c') # size
self.running_slap_box_scale.to_stream(data)
data.write(b'\x8ae\xfdg') # 0x8a65fd67
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_jumping_after_running_slap))
data.write(b'3g\xbc\xa4') # 0x3367bca4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_controller_motion_detection_time))
data.write(b'"\x15\xe6t') # 0x2215e674
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_from_roll_control_scalar))
data.write(b'yz\xa5Q') # 0x797aa551
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_jump_height))
data.write(b'8m\x9a\xd7') # 0x386d9ad7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_jump_height))
data.write(b'\x95\x83\xee\x9a') # 0x9583ee9a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_bounce_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\xb2a\xf8') # 0x16b261f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_horizontal_controller_movement_to_trigger_running_slap))
data.write(b'8uN\xc2') # 0x38754ec2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_speed_to_trigger_running_slap))
data.write(b'H\x85\xdf\xfa') # 0x4885dffa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed_multiplier))
data.write(b'\xc5\xa9!\xf0') # 0xc5a921f0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_duration))
data.write(b'^\xe0gj') # 0x5ee0676a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disallow_turn_duration))
data.write(b'+HPg') # 0x2b485067
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_slap_duration))
data.write(b'A3\xdb\xe2') # 0x4133dbe2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_between_rolls))
data.write(b'\x9a\xdaD\xf7') # 0x9ada44f7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll_attack_damage_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
running_slap_box_scale=Vector.from_json(data['running_slap_box_scale']),
delay_jumping_after_running_slap=data['delay_jumping_after_running_slap'],
roll_controller_motion_detection_time=data['roll_controller_motion_detection_time'],
jump_from_roll_control_scalar=data['jump_from_roll_control_scalar'],
minimum_jump_height=data['minimum_jump_height'],
maximum_jump_height=data['maximum_jump_height'],
attack_bounce_data=PlayerAttackBounceData.from_json(data['attack_bounce_data']),
min_horizontal_controller_movement_to_trigger_running_slap=data['min_horizontal_controller_movement_to_trigger_running_slap'],
min_speed_to_trigger_running_slap=data['min_speed_to_trigger_running_slap'],
speed_multiplier=data['speed_multiplier'],
roll_duration=data['roll_duration'],
disallow_turn_duration=data['disallow_turn_duration'],
roll_slap_duration=data['roll_slap_duration'],
delay_between_rolls=data['delay_between_rolls'],
roll_attack_damage_sound=data['roll_attack_damage_sound'],
)
def to_json(self) -> dict:
return {
'running_slap_box_scale': self.running_slap_box_scale.to_json(),
'delay_jumping_after_running_slap': self.delay_jumping_after_running_slap,
'roll_controller_motion_detection_time': self.roll_controller_motion_detection_time,
'jump_from_roll_control_scalar': self.jump_from_roll_control_scalar,
'minimum_jump_height': self.minimum_jump_height,
'maximum_jump_height': self.maximum_jump_height,
'attack_bounce_data': self.attack_bounce_data.to_json(),
'min_horizontal_controller_movement_to_trigger_running_slap': self.min_horizontal_controller_movement_to_trigger_running_slap,
'min_speed_to_trigger_running_slap': self.min_speed_to_trigger_running_slap,
'speed_multiplier': self.speed_multiplier,
'roll_duration': self.roll_duration,
'disallow_turn_duration': self.disallow_turn_duration,
'roll_slap_duration': self.roll_slap_duration,
'delay_between_rolls': self.delay_between_rolls,
'roll_attack_damage_sound': self.roll_attack_damage_sound,
}
def _decode_running_slap_box_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_delay_jumping_after_running_slap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_controller_motion_detection_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_from_roll_control_scalar(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_bounce_data(data: typing.BinaryIO, property_size: int):
return PlayerAttackBounceData.from_stream(data, property_size)
def _decode_min_horizontal_controller_movement_to_trigger_running_slap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_speed_to_trigger_running_slap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disallow_turn_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_slap_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_between_rolls(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_attack_damage_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x46322287: ('running_slap_box_scale', _decode_running_slap_box_scale),
0x8a65fd67: ('delay_jumping_after_running_slap', _decode_delay_jumping_after_running_slap),
0x3367bca4: ('roll_controller_motion_detection_time', _decode_roll_controller_motion_detection_time),
0x2215e674: ('jump_from_roll_control_scalar', _decode_jump_from_roll_control_scalar),
0x797aa551: ('minimum_jump_height', _decode_minimum_jump_height),
0x386d9ad7: ('maximum_jump_height', _decode_maximum_jump_height),
0x9583ee9a: ('attack_bounce_data', _decode_attack_bounce_data),
0x16b261f8: ('min_horizontal_controller_movement_to_trigger_running_slap', _decode_min_horizontal_controller_movement_to_trigger_running_slap),
0x38754ec2: ('min_speed_to_trigger_running_slap', _decode_min_speed_to_trigger_running_slap),
0x4885dffa: ('speed_multiplier', _decode_speed_multiplier),
0xc5a921f0: ('roll_duration', _decode_roll_duration),
0x5ee0676a: ('disallow_turn_duration', _decode_disallow_turn_duration),
0x2b485067: ('roll_slap_duration', _decode_roll_slap_duration),
0x4133dbe2: ('delay_between_rolls', _decode_delay_between_rolls),
0x9ada44f7: ('roll_attack_damage_sound', _decode_roll_attack_damage_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongRunningSlapData.py | 0.618435 | 0.327104 | KongRunningSlapData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class PlayerCling2Data(BaseProperty):
run_half_cone_for_stick: float = dataclasses.field(default=50.0)
off_angle_stick_response: Spline = dataclasses.field(default_factory=Spline)
acceleration_factor: Spline = dataclasses.field(default_factory=Spline)
max_velocity_factor: Spline = dataclasses.field(default_factory=Spline)
search_distance: float = dataclasses.field(default=10.0)
close_distance: float = dataclasses.field(default=6.5)
close_speed: float = dataclasses.field(default=15.0)
lock_distance: float = dataclasses.field(default=0.800000011920929)
ground_pound_window: float = dataclasses.field(default=0.25)
orientation_turn_speed: float = dataclasses.field(default=900.0)
surface_alignment_turn_speed: float = dataclasses.field(default=10800.0)
air_surface_alignment_turn_speed: float = dataclasses.field(default=500.0)
jump_lateral_speed_multiplier: float = dataclasses.field(default=1.5)
jump_lateral_initial_vert_speed: float = dataclasses.field(default=0.4000000059604645)
jump_lateral_modify_gravity_time: float = dataclasses.field(default=0.25)
jump_angled_speed_multiplier: float = dataclasses.field(default=1.0)
damage_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_effect_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=-2.0, y=0.4000000059604645, z=1.600000023841858))
shield_damage_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
shield_damage_effect_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
angled_jump_launch_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
on_edge_range: float = dataclasses.field(default=1.100000023841858)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x16') # 22 properties
data.write(b')\xa72d') # 0x29a73264
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.run_half_cone_for_stick))
data.write(b'k\xd2,u') # 0x6bd22c75
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.off_angle_stick_response.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xb1}X') # 0xb0b17d58
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.acceleration_factor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\x7f\xe8\xaa') # 0xc47fe8aa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.max_velocity_factor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa8\xac\x80\xdd') # 0xa8ac80dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_distance))
data.write(b'\xb5\xd2\xe3\x00') # 0xb5d2e300
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.close_distance))
data.write(b'q\xb1B\xca') # 0x71b142ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.close_speed))
data.write(b'\xeaw\x88\xc7') # 0xea7788c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lock_distance))
data.write(b'h\xd7\x87\xb4') # 0x68d787b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_window))
data.write(b'\xcd;_\\') # 0xcd3b5f5c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.orientation_turn_speed))
data.write(b'y\x0f\xf1\x9f') # 0x790ff19f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.surface_alignment_turn_speed))
data.write(b'BwH\x87') # 0x42774887
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_surface_alignment_turn_speed))
data.write(b'\xaa>#F') # 0xaa3e2346
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_lateral_speed_multiplier))
data.write(b'\xc4=e\x9a') # 0xc43d659a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_lateral_initial_vert_speed))
data.write(b'^\x81\x04Y') # 0x5e810459
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_lateral_modify_gravity_time))
data.write(b'\xe5\xa5\x16\x0e') # 0xe5a5160e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_angled_speed_multiplier))
data.write(b'\xc1\x10\xedD') # 0xc110ed44
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.damage_effect))
data.write(b'\x81E\x7f\xac') # 0x81457fac
data.write(b'\x00\x0c') # size
self.damage_effect_offset.to_stream(data)
data.write(b'I9^6') # 0x49395e36
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.shield_damage_effect))
data.write(b'\x82\xd0\x0c\xd4') # 0x82d00cd4
data.write(b'\x00\x0c') # size
self.shield_damage_effect_offset.to_stream(data)
data.write(b'\x19\x99\xe3\xd7') # 0x1999e3d7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.angled_jump_launch_sound))
data.write(b'@\xb3\xdaD') # 0x40b3da44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.on_edge_range))
@classmethod
def from_json(cls, data: dict):
return cls(
run_half_cone_for_stick=data['run_half_cone_for_stick'],
off_angle_stick_response=Spline.from_json(data['off_angle_stick_response']),
acceleration_factor=Spline.from_json(data['acceleration_factor']),
max_velocity_factor=Spline.from_json(data['max_velocity_factor']),
search_distance=data['search_distance'],
close_distance=data['close_distance'],
close_speed=data['close_speed'],
lock_distance=data['lock_distance'],
ground_pound_window=data['ground_pound_window'],
orientation_turn_speed=data['orientation_turn_speed'],
surface_alignment_turn_speed=data['surface_alignment_turn_speed'],
air_surface_alignment_turn_speed=data['air_surface_alignment_turn_speed'],
jump_lateral_speed_multiplier=data['jump_lateral_speed_multiplier'],
jump_lateral_initial_vert_speed=data['jump_lateral_initial_vert_speed'],
jump_lateral_modify_gravity_time=data['jump_lateral_modify_gravity_time'],
jump_angled_speed_multiplier=data['jump_angled_speed_multiplier'],
damage_effect=data['damage_effect'],
damage_effect_offset=Vector.from_json(data['damage_effect_offset']),
shield_damage_effect=data['shield_damage_effect'],
shield_damage_effect_offset=Vector.from_json(data['shield_damage_effect_offset']),
angled_jump_launch_sound=data['angled_jump_launch_sound'],
on_edge_range=data['on_edge_range'],
)
def to_json(self) -> dict:
return {
'run_half_cone_for_stick': self.run_half_cone_for_stick,
'off_angle_stick_response': self.off_angle_stick_response.to_json(),
'acceleration_factor': self.acceleration_factor.to_json(),
'max_velocity_factor': self.max_velocity_factor.to_json(),
'search_distance': self.search_distance,
'close_distance': self.close_distance,
'close_speed': self.close_speed,
'lock_distance': self.lock_distance,
'ground_pound_window': self.ground_pound_window,
'orientation_turn_speed': self.orientation_turn_speed,
'surface_alignment_turn_speed': self.surface_alignment_turn_speed,
'air_surface_alignment_turn_speed': self.air_surface_alignment_turn_speed,
'jump_lateral_speed_multiplier': self.jump_lateral_speed_multiplier,
'jump_lateral_initial_vert_speed': self.jump_lateral_initial_vert_speed,
'jump_lateral_modify_gravity_time': self.jump_lateral_modify_gravity_time,
'jump_angled_speed_multiplier': self.jump_angled_speed_multiplier,
'damage_effect': self.damage_effect,
'damage_effect_offset': self.damage_effect_offset.to_json(),
'shield_damage_effect': self.shield_damage_effect,
'shield_damage_effect_offset': self.shield_damage_effect_offset.to_json(),
'angled_jump_launch_sound': self.angled_jump_launch_sound,
'on_edge_range': self.on_edge_range,
}
def _decode_run_half_cone_for_stick(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_off_angle_stick_response(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_acceleration_factor(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_max_velocity_factor(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_search_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_close_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_close_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lock_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_pound_window(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_orientation_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_surface_alignment_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_air_surface_alignment_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_lateral_speed_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_lateral_initial_vert_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_lateral_modify_gravity_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_angled_speed_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_damage_effect_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_shield_damage_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_shield_damage_effect_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_angled_jump_launch_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_on_edge_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x29a73264: ('run_half_cone_for_stick', _decode_run_half_cone_for_stick),
0x6bd22c75: ('off_angle_stick_response', _decode_off_angle_stick_response),
0xb0b17d58: ('acceleration_factor', _decode_acceleration_factor),
0xc47fe8aa: ('max_velocity_factor', _decode_max_velocity_factor),
0xa8ac80dd: ('search_distance', _decode_search_distance),
0xb5d2e300: ('close_distance', _decode_close_distance),
0x71b142ca: ('close_speed', _decode_close_speed),
0xea7788c7: ('lock_distance', _decode_lock_distance),
0x68d787b4: ('ground_pound_window', _decode_ground_pound_window),
0xcd3b5f5c: ('orientation_turn_speed', _decode_orientation_turn_speed),
0x790ff19f: ('surface_alignment_turn_speed', _decode_surface_alignment_turn_speed),
0x42774887: ('air_surface_alignment_turn_speed', _decode_air_surface_alignment_turn_speed),
0xaa3e2346: ('jump_lateral_speed_multiplier', _decode_jump_lateral_speed_multiplier),
0xc43d659a: ('jump_lateral_initial_vert_speed', _decode_jump_lateral_initial_vert_speed),
0x5e810459: ('jump_lateral_modify_gravity_time', _decode_jump_lateral_modify_gravity_time),
0xe5a5160e: ('jump_angled_speed_multiplier', _decode_jump_angled_speed_multiplier),
0xc110ed44: ('damage_effect', _decode_damage_effect),
0x81457fac: ('damage_effect_offset', _decode_damage_effect_offset),
0x49395e36: ('shield_damage_effect', _decode_shield_damage_effect),
0x82d00cd4: ('shield_damage_effect_offset', _decode_shield_damage_effect_offset),
0x1999e3d7: ('angled_jump_launch_sound', _decode_angled_jump_launch_sound),
0x40b3da44: ('on_edge_range', _decode_on_edge_range),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerCling2Data.py | 0.631594 | 0.338514 | PlayerCling2Data.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.