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 TrackObjectModuleData(BaseProperty):
maximum_track_distance: float = dataclasses.field(default=15.0)
full_left_distance: float = dataclasses.field(default=10.0)
full_right_distance: 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\x03') # 3 properties
data.write(b'\x04\xf3\xde:') # 0x4f3de3a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_track_distance))
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))
@classmethod
def from_json(cls, data: dict):
return cls(
maximum_track_distance=data['maximum_track_distance'],
full_left_distance=data['full_left_distance'],
full_right_distance=data['full_right_distance'],
)
def to_json(self) -> dict:
return {
'maximum_track_distance': self.maximum_track_distance,
'full_left_distance': self.full_left_distance,
'full_right_distance': self.full_right_distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0x4f3de3a, 0x36dc8dd, 0x37a12336)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TrackObjectModuleData]:
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 TrackObjectModuleData(
dec[2],
dec[5],
dec[8],
)
def _decode_maximum_track_distance(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4f3de3a: ('maximum_track_distance', _decode_maximum_track_distance),
0x36dc8dd: ('full_left_distance', _decode_full_left_distance),
0x37a12336: ('full_right_distance', _decode_full_right_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TrackObjectModuleData.py | 0.80837 | 0.360236 | TrackObjectModuleData.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.archetypes.OffsetSplines import OffsetSplines
from retro_data_structures.properties.dkc_returns.archetypes.PathDetermination import PathDetermination
from retro_data_structures.properties.dkc_returns.archetypes.SpindleOrientation import SpindleOrientation
from retro_data_structures.properties.dkc_returns.archetypes.SurfaceOrientation import SurfaceOrientation
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct13 import UnknownStruct13
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct74 import UnknownStruct74
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class CameraOrientation(BaseProperty):
orientation_type: int = dataclasses.field(default=1973921119) # Choice
flags_orientation: int = dataclasses.field(default=8)
look_at_type: enums.LookAtType = dataclasses.field(default=enums.LookAtType.Unknown1)
locator_name: str = dataclasses.field(default='')
pitch_angle: float = dataclasses.field(default=0.0)
target_path_determination: PathDetermination = dataclasses.field(default_factory=PathDetermination)
distance: float = dataclasses.field(default=0.0)
distance_direction_method: enums.DistanceDirectionMethod = dataclasses.field(default=enums.DistanceDirectionMethod.Unknown1)
look_at_motion: Convergence = dataclasses.field(default_factory=Convergence)
look_at_offset: OffsetSplines = dataclasses.field(default_factory=OffsetSplines)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
unknown_struct13: UnknownStruct13 = dataclasses.field(default_factory=UnknownStruct13)
spindle_orientation: SpindleOrientation = dataclasses.field(default_factory=SpindleOrientation)
surface_orientation: SurfaceOrientation = dataclasses.field(default_factory=SurfaceOrientation)
unknown_struct74: UnknownStruct74 = dataclasses.field(default_factory=UnknownStruct74)
@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'\\r\xa9d') # 0x5c72a964
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.orientation_type))
data.write(b'b\x19\x02.') # 0x6219022e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_orientation))
data.write(b'D\x19\x1f\xb8') # 0x44191fb8
data.write(b'\x00\x04') # size
self.look_at_type.to_stream(data)
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'o\xf79.') # 0x6ff7392e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch_angle))
data.write(b'2F\x8c\x89') # 0x32468c89
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_path_determination.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'\x10\xe7\x12\x1b') # 0x10e7121b
data.write(b'\x00\x04') # size
self.distance_direction_method.to_stream(data)
data.write(b'\xdaT\xb3\xe9') # 0xda54b3e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_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'\t\x1f)6') # 0x91f2936
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xdf\xbf\xa7') # 0xc4dfbfa7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_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'\x0e\x1f \x94') # 0xe1f2094
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\xbc\x03\xd3') # 0x86bc03d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"\xe1\xde\xee'") # 0xe1deee27
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surface_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf6\xbbD\xea') # 0xf6bb44ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct74.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(
orientation_type=data['orientation_type'],
flags_orientation=data['flags_orientation'],
look_at_type=enums.LookAtType.from_json(data['look_at_type']),
locator_name=data['locator_name'],
pitch_angle=data['pitch_angle'],
target_path_determination=PathDetermination.from_json(data['target_path_determination']),
distance=data['distance'],
distance_direction_method=enums.DistanceDirectionMethod.from_json(data['distance_direction_method']),
look_at_motion=Convergence.from_json(data['look_at_motion']),
look_at_offset=OffsetSplines.from_json(data['look_at_offset']),
target_control_spline=Spline.from_json(data['target_control_spline']),
unknown_struct13=UnknownStruct13.from_json(data['unknown_struct13']),
spindle_orientation=SpindleOrientation.from_json(data['spindle_orientation']),
surface_orientation=SurfaceOrientation.from_json(data['surface_orientation']),
unknown_struct74=UnknownStruct74.from_json(data['unknown_struct74']),
)
def to_json(self) -> dict:
return {
'orientation_type': self.orientation_type,
'flags_orientation': self.flags_orientation,
'look_at_type': self.look_at_type.to_json(),
'locator_name': self.locator_name,
'pitch_angle': self.pitch_angle,
'target_path_determination': self.target_path_determination.to_json(),
'distance': self.distance,
'distance_direction_method': self.distance_direction_method.to_json(),
'look_at_motion': self.look_at_motion.to_json(),
'look_at_offset': self.look_at_offset.to_json(),
'target_control_spline': self.target_control_spline.to_json(),
'unknown_struct13': self.unknown_struct13.to_json(),
'spindle_orientation': self.spindle_orientation.to_json(),
'surface_orientation': self.surface_orientation.to_json(),
'unknown_struct74': self.unknown_struct74.to_json(),
}
def _decode_orientation_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_flags_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_look_at_type(data: typing.BinaryIO, property_size: int):
return enums.LookAtType.from_stream(data)
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_pitch_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_path_determination(data: typing.BinaryIO, property_size: int):
return PathDetermination.from_stream(data, property_size)
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance_direction_method(data: typing.BinaryIO, property_size: int):
return enums.DistanceDirectionMethod.from_stream(data)
def _decode_look_at_motion(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size, default_override={'convergence_type': enums.ConvergenceType.Unknown1})
def _decode_look_at_offset(data: typing.BinaryIO, property_size: int):
return OffsetSplines.from_stream(data, property_size)
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_struct13(data: typing.BinaryIO, property_size: int):
return UnknownStruct13.from_stream(data, property_size)
def _decode_spindle_orientation(data: typing.BinaryIO, property_size: int):
return SpindleOrientation.from_stream(data, property_size)
def _decode_surface_orientation(data: typing.BinaryIO, property_size: int):
return SurfaceOrientation.from_stream(data, property_size)
def _decode_unknown_struct74(data: typing.BinaryIO, property_size: int):
return UnknownStruct74.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5c72a964: ('orientation_type', _decode_orientation_type),
0x6219022e: ('flags_orientation', _decode_flags_orientation),
0x44191fb8: ('look_at_type', _decode_look_at_type),
0xfbc6c110: ('locator_name', _decode_locator_name),
0x6ff7392e: ('pitch_angle', _decode_pitch_angle),
0x32468c89: ('target_path_determination', _decode_target_path_determination),
0xc3bf43be: ('distance', _decode_distance),
0x10e7121b: ('distance_direction_method', _decode_distance_direction_method),
0xda54b3e9: ('look_at_motion', _decode_look_at_motion),
0x91f2936: ('look_at_offset', _decode_look_at_offset),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0xe1f2094: ('unknown_struct13', _decode_unknown_struct13),
0x86bc03d3: ('spindle_orientation', _decode_spindle_orientation),
0xe1deee27: ('surface_orientation', _decode_surface_orientation),
0xf6bb44ea: ('unknown_struct74', _decode_unknown_struct74),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraOrientation.py | 0.572245 | 0.29419 | CameraOrientation.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 PlayerTarInteractionData(BaseProperty):
uses_tar_in_this_level: bool = dataclasses.field(default=False)
inhibit_player_on_tar_pit_exit: bool = dataclasses.field(default=True)
num_tar_inhibitors_for_tar_mode: int = dataclasses.field(default=3)
num_ground_pounds_to_break_tar_mode: int = dataclasses.field(default=3)
ground_pound_cool_down: float = dataclasses.field(default=1.0)
tar_ground_pound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
tar_ground_pound_effect_locator: str = dataclasses.field(default='')
tar_jump_land_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
tar_jump_land_effect_locator: str = dataclasses.field(default='')
tar_liberation_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
tar_liberation_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
tar_liberation_effect_locator: 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\x0c') # 12 properties
data.write(b'\xb5N\xef\xd1') # 0xb54eefd1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.uses_tar_in_this_level))
data.write(b'|\x94\xaa;') # 0x7c94aa3b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.inhibit_player_on_tar_pit_exit))
data.write(b'\x00\xf4\x92\x00') # 0xf49200
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_tar_inhibitors_for_tar_mode))
data.write(b' \xab\x95\xe5') # 0x20ab95e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_ground_pounds_to_break_tar_mode))
data.write(b']\xb3\xfa\x1f') # 0x5db3fa1f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_cool_down))
data.write(b'y\x8fw@') # 0x798f7740
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.tar_ground_pound_effect))
data.write(b'\x1ck\x87\xa3') # 0x1c6b87a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.tar_ground_pound_effect_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'Q\xea)\xb6') # 0x51ea29b6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.tar_jump_land_effect))
data.write(b'\xff\r\xf2\xa8') # 0xff0df2a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.tar_jump_land_effect_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'~\xe0\x95\xe2') # 0x7ee095e2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.tar_liberation_effect))
data.write(b'\x1e\xf4X\xc4') # 0x1ef458c4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.tar_liberation_sound))
data.write(b'+\xbe\xb1\xf3') # 0x2bbeb1f3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.tar_liberation_effect_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)
@classmethod
def from_json(cls, data: dict):
return cls(
uses_tar_in_this_level=data['uses_tar_in_this_level'],
inhibit_player_on_tar_pit_exit=data['inhibit_player_on_tar_pit_exit'],
num_tar_inhibitors_for_tar_mode=data['num_tar_inhibitors_for_tar_mode'],
num_ground_pounds_to_break_tar_mode=data['num_ground_pounds_to_break_tar_mode'],
ground_pound_cool_down=data['ground_pound_cool_down'],
tar_ground_pound_effect=data['tar_ground_pound_effect'],
tar_ground_pound_effect_locator=data['tar_ground_pound_effect_locator'],
tar_jump_land_effect=data['tar_jump_land_effect'],
tar_jump_land_effect_locator=data['tar_jump_land_effect_locator'],
tar_liberation_effect=data['tar_liberation_effect'],
tar_liberation_sound=data['tar_liberation_sound'],
tar_liberation_effect_locator=data['tar_liberation_effect_locator'],
)
def to_json(self) -> dict:
return {
'uses_tar_in_this_level': self.uses_tar_in_this_level,
'inhibit_player_on_tar_pit_exit': self.inhibit_player_on_tar_pit_exit,
'num_tar_inhibitors_for_tar_mode': self.num_tar_inhibitors_for_tar_mode,
'num_ground_pounds_to_break_tar_mode': self.num_ground_pounds_to_break_tar_mode,
'ground_pound_cool_down': self.ground_pound_cool_down,
'tar_ground_pound_effect': self.tar_ground_pound_effect,
'tar_ground_pound_effect_locator': self.tar_ground_pound_effect_locator,
'tar_jump_land_effect': self.tar_jump_land_effect,
'tar_jump_land_effect_locator': self.tar_jump_land_effect_locator,
'tar_liberation_effect': self.tar_liberation_effect,
'tar_liberation_sound': self.tar_liberation_sound,
'tar_liberation_effect_locator': self.tar_liberation_effect_locator,
}
def _decode_uses_tar_in_this_level(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_inhibit_player_on_tar_pit_exit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_num_tar_inhibitors_for_tar_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_num_ground_pounds_to_break_tar_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_ground_pound_cool_down(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tar_ground_pound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_tar_ground_pound_effect_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_tar_jump_land_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_tar_jump_land_effect_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_tar_liberation_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_tar_liberation_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_tar_liberation_effect_locator(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]]] = {
0xb54eefd1: ('uses_tar_in_this_level', _decode_uses_tar_in_this_level),
0x7c94aa3b: ('inhibit_player_on_tar_pit_exit', _decode_inhibit_player_on_tar_pit_exit),
0xf49200: ('num_tar_inhibitors_for_tar_mode', _decode_num_tar_inhibitors_for_tar_mode),
0x20ab95e5: ('num_ground_pounds_to_break_tar_mode', _decode_num_ground_pounds_to_break_tar_mode),
0x5db3fa1f: ('ground_pound_cool_down', _decode_ground_pound_cool_down),
0x798f7740: ('tar_ground_pound_effect', _decode_tar_ground_pound_effect),
0x1c6b87a3: ('tar_ground_pound_effect_locator', _decode_tar_ground_pound_effect_locator),
0x51ea29b6: ('tar_jump_land_effect', _decode_tar_jump_land_effect),
0xff0df2a8: ('tar_jump_land_effect_locator', _decode_tar_jump_land_effect_locator),
0x7ee095e2: ('tar_liberation_effect', _decode_tar_liberation_effect),
0x1ef458c4: ('tar_liberation_sound', _decode_tar_liberation_sound),
0x2bbeb1f3: ('tar_liberation_effect_locator', _decode_tar_liberation_effect_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerTarInteractionData.py | 0.467818 | 0.205276 | PlayerTarInteractionData.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 UnknownStruct266(BaseProperty):
max_impulse_speed: float = dataclasses.field(default=0.0)
acceleration: float = dataclasses.field(default=0.0)
duration: float = dataclasses.field(default=0.0)
cool_down_deceleration: float = dataclasses.field(default=0.0)
passive_deceleration: float = dataclasses.field(default=0.0)
max_passive_speed: 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\x06') # 6 properties
data.write(b'\xecF\x16\x86') # 0xec461686
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_impulse_speed))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\xa4\xb2\xd2x') # 0xa4b2d278
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cool_down_deceleration))
data.write(b'\x81\x17\r!') # 0x81170d21
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.passive_deceleration))
data.write(b'Q\xb0="') # 0x51b03d22
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_passive_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
max_impulse_speed=data['max_impulse_speed'],
acceleration=data['acceleration'],
duration=data['duration'],
cool_down_deceleration=data['cool_down_deceleration'],
passive_deceleration=data['passive_deceleration'],
max_passive_speed=data['max_passive_speed'],
)
def to_json(self) -> dict:
return {
'max_impulse_speed': self.max_impulse_speed,
'acceleration': self.acceleration,
'duration': self.duration,
'cool_down_deceleration': self.cool_down_deceleration,
'passive_deceleration': self.passive_deceleration,
'max_passive_speed': self.max_passive_speed,
}
_FAST_FORMAT = None
_FAST_IDS = (0xec461686, 0x39fb7978, 0x8b51e23f, 0xa4b2d278, 0x81170d21, 0x51b03d22)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct266]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHf')
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 UnknownStruct266(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_max_impulse_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cool_down_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_passive_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_passive_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]]] = {
0xec461686: ('max_impulse_speed', _decode_max_impulse_speed),
0x39fb7978: ('acceleration', _decode_acceleration),
0x8b51e23f: ('duration', _decode_duration),
0xa4b2d278: ('cool_down_deceleration', _decode_cool_down_deceleration),
0x81170d21: ('passive_deceleration', _decode_passive_deceleration),
0x51b03d22: ('max_passive_speed', _decode_max_passive_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct266.py | 0.689828 | 0.282785 | UnknownStruct266.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 UnknownStruct85(BaseProperty):
start_hidden: bool = dataclasses.field(default=True)
minimum_hide_time: float = dataclasses.field(default=0.5)
maximum_hide_time: 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'M\xef{\x9b') # 0x4def7b9b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_hidden))
data.write(b'\xcc}\x17\xd6') # 0xcc7d17d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_hide_time))
data.write(b'\xe5\x03\xea\xce') # 0xe503eace
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_hide_time))
@classmethod
def from_json(cls, data: dict):
return cls(
start_hidden=data['start_hidden'],
minimum_hide_time=data['minimum_hide_time'],
maximum_hide_time=data['maximum_hide_time'],
)
def to_json(self) -> dict:
return {
'start_hidden': self.start_hidden,
'minimum_hide_time': self.minimum_hide_time,
'maximum_hide_time': self.maximum_hide_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0x4def7b9b, 0xcc7d17d6, 0xe503eace)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct85]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHf')
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 UnknownStruct85(
dec[2],
dec[5],
dec[8],
)
def _decode_start_hidden(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_hide_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_hide_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]]] = {
0x4def7b9b: ('start_hidden', _decode_start_hidden),
0xcc7d17d6: ('minimum_hide_time', _decode_minimum_hide_time),
0xe503eace: ('maximum_hide_time', _decode_maximum_hide_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct85.py | 0.733261 | 0.333476 | UnknownStruct85.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 ProjectileCollisionData(BaseProperty):
unknown_0xa9f8a74f: int = dataclasses.field(default=64)
collision_type: int = dataclasses.field(default=988868003) # Choice
sphere_radius: float = dataclasses.field(default=1.0)
unknown_0xfef3d2da: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x2918609b: 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'\xa9\xf8\xa7O') # 0xa9f8a74f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xa9f8a74f))
data.write(b'\xb6t\xea=') # 0xb674ea3d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.collision_type))
data.write(b'\xf3\xd6\xe9Y') # 0xf3d6e959
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.sphere_radius))
data.write(b'\xfe\xf3\xd2\xda') # 0xfef3d2da
data.write(b'\x00\x0c') # size
self.unknown_0xfef3d2da.to_stream(data)
data.write(b')\x18`\x9b') # 0x2918609b
data.write(b'\x00\x0c') # size
self.unknown_0x2918609b.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xa9f8a74f=data['unknown_0xa9f8a74f'],
collision_type=data['collision_type'],
sphere_radius=data['sphere_radius'],
unknown_0xfef3d2da=Vector.from_json(data['unknown_0xfef3d2da']),
unknown_0x2918609b=Vector.from_json(data['unknown_0x2918609b']),
)
def to_json(self) -> dict:
return {
'unknown_0xa9f8a74f': self.unknown_0xa9f8a74f,
'collision_type': self.collision_type,
'sphere_radius': self.sphere_radius,
'unknown_0xfef3d2da': self.unknown_0xfef3d2da.to_json(),
'unknown_0x2918609b': self.unknown_0x2918609b.to_json(),
}
def _decode_unknown_0xa9f8a74f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_collision_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sphere_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfef3d2da(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x2918609b(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]]] = {
0xa9f8a74f: ('unknown_0xa9f8a74f', _decode_unknown_0xa9f8a74f),
0xb674ea3d: ('collision_type', _decode_collision_type),
0xf3d6e959: ('sphere_radius', _decode_sphere_radius),
0xfef3d2da: ('unknown_0xfef3d2da', _decode_unknown_0xfef3d2da),
0x2918609b: ('unknown_0x2918609b', _decode_unknown_0x2918609b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileCollisionData.py | 0.690872 | 0.349477 | ProjectileCollisionData.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 DashModifierData(BaseProperty):
unknown: 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'!t\x03\xaf') # 0x217403af
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
}
_FAST_FORMAT = None
_FAST_IDS = (0x217403af)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DashModifierData]:
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 DashModifierData(
dec[2],
)
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]]] = {
0x217403af: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DashModifierData.py | 0.645902 | 0.293227 | DashModifierData.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 UnknownStruct22(BaseProperty):
destroy_timer: float = dataclasses.field(default=0.0)
respawn_offscreen: bool = dataclasses.field(default=True)
offscreen_respawn_distance: 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\x03') # 3 properties
data.write(b'!\x97\x04\x04') # 0x21970404
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.destroy_timer))
data.write(b'\x10\xd2\x83\x08') # 0x10d28308
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.respawn_offscreen))
data.write(b"'eOF") # 0x27654f46
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.offscreen_respawn_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
destroy_timer=data['destroy_timer'],
respawn_offscreen=data['respawn_offscreen'],
offscreen_respawn_distance=data['offscreen_respawn_distance'],
)
def to_json(self) -> dict:
return {
'destroy_timer': self.destroy_timer,
'respawn_offscreen': self.respawn_offscreen,
'offscreen_respawn_distance': self.offscreen_respawn_distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0x21970404, 0x10d28308, 0x27654f46)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct22]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?LHf')
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 UnknownStruct22(
dec[2],
dec[5],
dec[8],
)
def _decode_destroy_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_respawn_offscreen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_offscreen_respawn_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]]] = {
0x21970404: ('destroy_timer', _decode_destroy_timer),
0x10d28308: ('respawn_offscreen', _decode_respawn_offscreen),
0x27654f46: ('offscreen_respawn_distance', _decode_offscreen_respawn_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct22.py | 0.616705 | 0.285447 | UnknownStruct22.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 UnknownStruct199(BaseProperty):
spline_target_type: enums.SplineTargetType = dataclasses.field(default=enums.SplineTargetType.Unknown2)
unknown_0xef531185: float = dataclasses.field(default=0.0)
unknown_0x7a0d286c: float = dataclasses.field(default=3.0)
horizontal_motion: Spline = dataclasses.field(default_factory=Spline)
vertical_motion: Spline = dataclasses.field(default_factory=Spline)
only_target_active: 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\x06') # 6 properties
data.write(b'h#\x0be') # 0x68230b65
data.write(b'\x00\x04') # size
self.spline_target_type.to_stream(data)
data.write(b'\xefS\x11\x85') # 0xef531185
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xef531185))
data.write(b'z\r(l') # 0x7a0d286c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7a0d286c))
data.write(b'\xf1"\xcd\x97') # 0xf122cd97
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.horizontal_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b")'\xe5D") # 0x2927e544
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vertical_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x03d\xf0\xb8') # 0x364f0b8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.only_target_active))
@classmethod
def from_json(cls, data: dict):
return cls(
spline_target_type=enums.SplineTargetType.from_json(data['spline_target_type']),
unknown_0xef531185=data['unknown_0xef531185'],
unknown_0x7a0d286c=data['unknown_0x7a0d286c'],
horizontal_motion=Spline.from_json(data['horizontal_motion']),
vertical_motion=Spline.from_json(data['vertical_motion']),
only_target_active=data['only_target_active'],
)
def to_json(self) -> dict:
return {
'spline_target_type': self.spline_target_type.to_json(),
'unknown_0xef531185': self.unknown_0xef531185,
'unknown_0x7a0d286c': self.unknown_0x7a0d286c,
'horizontal_motion': self.horizontal_motion.to_json(),
'vertical_motion': self.vertical_motion.to_json(),
'only_target_active': self.only_target_active,
}
def _decode_spline_target_type(data: typing.BinaryIO, property_size: int):
return enums.SplineTargetType.from_stream(data)
def _decode_unknown_0xef531185(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7a0d286c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horizontal_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_vertical_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_only_target_active(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]]] = {
0x68230b65: ('spline_target_type', _decode_spline_target_type),
0xef531185: ('unknown_0xef531185', _decode_unknown_0xef531185),
0x7a0d286c: ('unknown_0x7a0d286c', _decode_unknown_0x7a0d286c),
0xf122cd97: ('horizontal_motion', _decode_horizontal_motion),
0x2927e544: ('vertical_motion', _decode_vertical_motion),
0x364f0b8: ('only_target_active', _decode_only_target_active),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct199.py | 0.61173 | 0.253728 | UnknownStruct199.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 PlayerMeleeData(BaseProperty):
melee_enabled: bool = dataclasses.field(default=False)
autonomous_melee_enabled: bool = dataclasses.field(default=False)
front_creature_melee_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rear_creature_melee_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
controller_melee_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]
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'\xfds\xa4\x04') # 0xfd73a404
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.melee_enabled))
data.write(b'",#}') # 0x222c237d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.autonomous_melee_enabled))
data.write(b'\x117\x1f\xad') # 0x11371fad
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.front_creature_melee_sound))
data.write(b'M\x12~\xcf') # 0x4d127ecf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rear_creature_melee_sound))
data.write(b'L\xc4\xe3\x9d') # 0x4cc4e39d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.controller_melee_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
melee_enabled=data['melee_enabled'],
autonomous_melee_enabled=data['autonomous_melee_enabled'],
front_creature_melee_sound=data['front_creature_melee_sound'],
rear_creature_melee_sound=data['rear_creature_melee_sound'],
controller_melee_sound=data['controller_melee_sound'],
)
def to_json(self) -> dict:
return {
'melee_enabled': self.melee_enabled,
'autonomous_melee_enabled': self.autonomous_melee_enabled,
'front_creature_melee_sound': self.front_creature_melee_sound,
'rear_creature_melee_sound': self.rear_creature_melee_sound,
'controller_melee_sound': self.controller_melee_sound,
}
_FAST_FORMAT = None
_FAST_IDS = (0xfd73a404, 0x222c237d, 0x11371fad, 0x4d127ecf, 0x4cc4e39d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerMeleeData]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(56))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return PlayerMeleeData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_melee_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_autonomous_melee_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_front_creature_melee_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rear_creature_melee_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_controller_melee_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]]] = {
0xfd73a404: ('melee_enabled', _decode_melee_enabled),
0x222c237d: ('autonomous_melee_enabled', _decode_autonomous_melee_enabled),
0x11371fad: ('front_creature_melee_sound', _decode_front_creature_melee_sound),
0x4d127ecf: ('rear_creature_melee_sound', _decode_rear_creature_melee_sound),
0x4cc4e39d: ('controller_melee_sound', _decode_controller_melee_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMeleeData.py | 0.57344 | 0.222025 | PlayerMeleeData.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 JungleBossStructB(BaseProperty):
unknown: enums.Unknown = dataclasses.field(default=enums.Unknown.Unknown7)
collision_actor_name: 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\x02') # 2 properties
data.write(b'\x0f\t\x993') # 0xf099933
data.write(b'\x00\x04') # size
self.unknown.to_stream(data)
data.write(b'l\x80_V') # 0x6c805f56
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.collision_actor_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)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=enums.Unknown.from_json(data['unknown']),
collision_actor_name=data['collision_actor_name'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown.to_json(),
'collision_actor_name': self.collision_actor_name,
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return enums.Unknown.from_stream(data)
def _decode_collision_actor_name(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]]] = {
0xf099933: ('unknown', _decode_unknown),
0x6c805f56: ('collision_actor_name', _decode_collision_actor_name),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/JungleBossStructB.py | 0.601242 | 0.289205 | JungleBossStructB.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 DynamicLightParent(BaseProperty):
unknown_0xddd74295: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x88f018b3: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
locator_name: str = dataclasses.field(default='')
use_parent_rotation: 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\x04') # 4 properties
data.write(b'\xdd\xd7B\x95') # 0xddd74295
data.write(b'\x00\x0c') # size
self.unknown_0xddd74295.to_stream(data)
data.write(b'\x88\xf0\x18\xb3') # 0x88f018b3
data.write(b'\x00\x0c') # size
self.unknown_0x88f018b3.to_stream(data)
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'\xf7.\xef\xbd') # 0xf72eefbd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_parent_rotation))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xddd74295=Vector.from_json(data['unknown_0xddd74295']),
unknown_0x88f018b3=Vector.from_json(data['unknown_0x88f018b3']),
locator_name=data['locator_name'],
use_parent_rotation=data['use_parent_rotation'],
)
def to_json(self) -> dict:
return {
'unknown_0xddd74295': self.unknown_0xddd74295.to_json(),
'unknown_0x88f018b3': self.unknown_0x88f018b3.to_json(),
'locator_name': self.locator_name,
'use_parent_rotation': self.use_parent_rotation,
}
def _decode_unknown_0xddd74295(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x88f018b3(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
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_use_parent_rotation(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]]] = {
0xddd74295: ('unknown_0xddd74295', _decode_unknown_0xddd74295),
0x88f018b3: ('unknown_0x88f018b3', _decode_unknown_0x88f018b3),
0xfbc6c110: ('locator_name', _decode_locator_name),
0xf72eefbd: ('use_parent_rotation', _decode_use_parent_rotation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DynamicLightParent.py | 0.68056 | 0.354657 | DynamicLightParent.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 SpawnBehaviorData(BaseProperty):
play_spawn_animation: bool = dataclasses.field(default=True)
use_animation_to_drive_movement: 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\x02') # 2 properties
data.write(b'\xa3<\xd7~') # 0xa33cd77e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.play_spawn_animation))
data.write(b'\x80\xe7\x00\xbd') # 0x80e700bd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_animation_to_drive_movement))
@classmethod
def from_json(cls, data: dict):
return cls(
play_spawn_animation=data['play_spawn_animation'],
use_animation_to_drive_movement=data['use_animation_to_drive_movement'],
)
def to_json(self) -> dict:
return {
'play_spawn_animation': self.play_spawn_animation,
'use_animation_to_drive_movement': self.use_animation_to_drive_movement,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa33cd77e, 0x80e700bd)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SpawnBehaviorData]:
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 SpawnBehaviorData(
dec[2],
dec[5],
)
def _decode_play_spawn_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_animation_to_drive_movement(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]]] = {
0xa33cd77e: ('play_spawn_animation', _decode_play_spawn_animation),
0x80e700bd: ('use_animation_to_drive_movement', _decode_use_animation_to_drive_movement),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SpawnBehaviorData.py | 0.611266 | 0.304604 | SpawnBehaviorData.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 UnknownStruct119(BaseProperty):
unknown_0x835677a5: float = dataclasses.field(default=0.0)
return_speed: float = dataclasses.field(default=5.0)
unknown_0x9b6c3ae4: float = dataclasses.field(default=4.0)
unknown_0x6893e2ce: float = dataclasses.field(default=4.0)
max_layer_activation: float = dataclasses.field(default=4.0)
stun_time: float = dataclasses.field(default=4.0)
unknown_0x34d15039: float = dataclasses.field(default=1.0)
unknown_0xa407c02a: float = dataclasses.field(default=2.0)
unknown_0x60e63efc: float = dataclasses.field(default=4.0)
unknown_0x9963bf82: float = dataclasses.field(default=2.0)
hold_locator: str = dataclasses.field(default='')
unknown_0x3311ba2b: 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]
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'\x83Vw\xa5') # 0x835677a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x835677a5))
data.write(b'\xcc($\x9e') # 0xcc28249e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.return_speed))
data.write(b'\x9bl:\xe4') # 0x9b6c3ae4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9b6c3ae4))
data.write(b'h\x93\xe2\xce') # 0x6893e2ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6893e2ce))
data.write(b'\xb9W%\xac') # 0xb95725ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_layer_activation))
data.write(b'~\x19#\x95') # 0x7e192395
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_time))
data.write(b'4\xd1P9') # 0x34d15039
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x34d15039))
data.write(b'\xa4\x07\xc0*') # 0xa407c02a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa407c02a))
data.write(b'`\xe6>\xfc') # 0x60e63efc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x60e63efc))
data.write(b'\x99c\xbf\x82') # 0x9963bf82
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9963bf82))
data.write(b'\xd2\xba\x948') # 0xd2ba9438
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.hold_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'3\x11\xba+') # 0x3311ba2b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x3311ba2b))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x835677a5=data['unknown_0x835677a5'],
return_speed=data['return_speed'],
unknown_0x9b6c3ae4=data['unknown_0x9b6c3ae4'],
unknown_0x6893e2ce=data['unknown_0x6893e2ce'],
max_layer_activation=data['max_layer_activation'],
stun_time=data['stun_time'],
unknown_0x34d15039=data['unknown_0x34d15039'],
unknown_0xa407c02a=data['unknown_0xa407c02a'],
unknown_0x60e63efc=data['unknown_0x60e63efc'],
unknown_0x9963bf82=data['unknown_0x9963bf82'],
hold_locator=data['hold_locator'],
unknown_0x3311ba2b=data['unknown_0x3311ba2b'],
)
def to_json(self) -> dict:
return {
'unknown_0x835677a5': self.unknown_0x835677a5,
'return_speed': self.return_speed,
'unknown_0x9b6c3ae4': self.unknown_0x9b6c3ae4,
'unknown_0x6893e2ce': self.unknown_0x6893e2ce,
'max_layer_activation': self.max_layer_activation,
'stun_time': self.stun_time,
'unknown_0x34d15039': self.unknown_0x34d15039,
'unknown_0xa407c02a': self.unknown_0xa407c02a,
'unknown_0x60e63efc': self.unknown_0x60e63efc,
'unknown_0x9963bf82': self.unknown_0x9963bf82,
'hold_locator': self.hold_locator,
'unknown_0x3311ba2b': self.unknown_0x3311ba2b,
}
def _decode_unknown_0x835677a5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_return_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9b6c3ae4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6893e2ce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_layer_activation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x34d15039(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa407c02a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x60e63efc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9963bf82(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hold_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x3311ba2b(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]]] = {
0x835677a5: ('unknown_0x835677a5', _decode_unknown_0x835677a5),
0xcc28249e: ('return_speed', _decode_return_speed),
0x9b6c3ae4: ('unknown_0x9b6c3ae4', _decode_unknown_0x9b6c3ae4),
0x6893e2ce: ('unknown_0x6893e2ce', _decode_unknown_0x6893e2ce),
0xb95725ac: ('max_layer_activation', _decode_max_layer_activation),
0x7e192395: ('stun_time', _decode_stun_time),
0x34d15039: ('unknown_0x34d15039', _decode_unknown_0x34d15039),
0xa407c02a: ('unknown_0xa407c02a', _decode_unknown_0xa407c02a),
0x60e63efc: ('unknown_0x60e63efc', _decode_unknown_0x60e63efc),
0x9963bf82: ('unknown_0x9963bf82', _decode_unknown_0x9963bf82),
0xd2ba9438: ('hold_locator', _decode_hold_locator),
0x3311ba2b: ('unknown_0x3311ba2b', _decode_unknown_0x3311ba2b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct119.py | 0.586286 | 0.24998 | UnknownStruct119.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.DebrisPropertiesOrientationEnum import DebrisPropertiesOrientationEnum
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct17 import UnknownStruct17
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Color import Color
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class DebrisProperties(BaseProperty):
cone_spread_yaw: float = dataclasses.field(default=180.0)
cone_spread_pitch: float = dataclasses.field(default=180.0)
initial_direction: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=1.0))
position_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
transform_position_offset: bool = dataclasses.field(default=True)
minimum_speed: float = dataclasses.field(default=5.0)
maximum_speed: float = dataclasses.field(default=15.0)
minimum_spin_speed: Vector = dataclasses.field(default_factory=lambda: Vector(x=-1.0, y=-1.0, z=-1.0))
maximum_spin_speed: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
minimum_lifetime: float = dataclasses.field(default=2.0)
maximum_lifetime: float = dataclasses.field(default=3.0)
disable_collision_time: float = dataclasses.field(default=0.0)
fade_in_end_percentage: float = dataclasses.field(default=10.0)
fade_out_start_percentage: float = dataclasses.field(default=80.0)
start_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
middle_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
end_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
unknown_0xd79690b4: bool = dataclasses.field(default=False)
unknown_0x0145d02d: bool = dataclasses.field(default=False)
scale_start_percentage: float = dataclasses.field(default=80.0)
final_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_0x417f4a91: float = dataclasses.field(default=0.375)
friction: float = dataclasses.field(default=0.10000000149011612)
gravity: float = dataclasses.field(default=25.0)
disable_physics_threshold: float = dataclasses.field(default=1.0)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
model_pivot_point: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
created_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
max_bounce_sounds: int = dataclasses.field(default=1)
unknown_0x76c79503: float = dataclasses.field(default=1.0)
unknown_0x310dfac8: float = dataclasses.field(default=1.0)
unknown_0x5e9f5215: float = dataclasses.field(default=0.10000000149011612)
unknown_0x39743618: float = dataclasses.field(default=0.10000000149011612)
unknown_0x33e0fbb4: float = dataclasses.field(default=0.10000000149011612)
unknown_0xe82e7ed7: float = dataclasses.field(default=0.10000000149011612)
unknown_0x855ee21b: float = dataclasses.field(default=0.10000000149011612)
particle_system1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_system1_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system1_uses_global_translation: bool = dataclasses.field(default=False)
particle_system1_uses_global_orientation: bool = dataclasses.field(default=False)
particle_system1_wait_for_particles_to_die: bool = dataclasses.field(default=True)
particle_system1_orientation: DebrisPropertiesOrientationEnum = dataclasses.field(default_factory=DebrisPropertiesOrientationEnum)
particle_system2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_system2_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system2_uses_global_translation: bool = dataclasses.field(default=False)
particle_system2_uses_global_orientation: bool = dataclasses.field(default=False)
particle_system2_wait_for_particles_to_die: bool = dataclasses.field(default=True)
particle_system2_orientation: DebrisPropertiesOrientationEnum = dataclasses.field(default_factory=DebrisPropertiesOrientationEnum)
bounce_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
bounce_particle_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
bounce_effect_transform: UnknownStruct17 = dataclasses.field(default_factory=UnknownStruct17)
is_collider: bool = dataclasses.field(default=True)
unknown_0xe73b9eb0: bool = dataclasses.field(default=True)
die_on_collision: bool = dataclasses.field(default=False)
unknown_0x8723498a: bool = dataclasses.field(default=False)
unknown_0x0f2c673e: int = dataclasses.field(default=0)
collide_with_characters: bool = dataclasses.field(default=False)
unknown_0x8ec68a96: bool = dataclasses.field(default=False)
fixed_bounce_speed_x: float = dataclasses.field(default=1.0)
fixed_bounce_speed_y: float = dataclasses.field(default=1.0)
unknown_0xbfd82a19: bool = dataclasses.field(default=False)
unknown_0x723d42d6: bool = dataclasses.field(default=True)
unknown_0x4edb1d0e: bool = dataclasses.field(default=False)
unknown_0xbf496273: bool = dataclasses.field(default=False)
unknown_0xf83c1c1f: bool = dataclasses.field(default=False)
unknown_0x88b1af46: bool = dataclasses.field(default=True)
render_in_foreground: bool = dataclasses.field(default=False)
allow_silhouette: bool = dataclasses.field(default=True)
unknown_0xe5eced02: 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'\x00F') # 70 properties
data.write(b'\\<JW') # 0x5c3c4a57
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cone_spread_yaw))
data.write(b'\xa7\x9f\xc5_') # 0xa79fc55f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cone_spread_pitch))
data.write(b'\x01\xa0\xdf\xe6') # 0x1a0dfe6
data.write(b'\x00\x0c') # size
self.initial_direction.to_stream(data)
data.write(b'\xef\x90\xf0\x9d') # 0xef90f09d
data.write(b'\x00\x0c') # size
self.position_offset.to_stream(data)
data.write(b'\xc4\xb1\xe6\xa1') # 0xc4b1e6a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.transform_position_offset))
data.write(b'\x01\x85&>') # 0x185263e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_speed))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
data.write(b'\xf7\x8c\x8a\xc7') # 0xf78c8ac7
data.write(b'\x00\x0c') # size
self.minimum_spin_speed.to_stream(data)
data.write(b'\xb6\x9b\xb5A') # 0xb69bb541
data.write(b'\x00\x0c') # size
self.maximum_spin_speed.to_stream(data)
data.write(b'\xd6YF"') # 0xd6594622
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_lifetime))
data.write(b"\xff'\xbb:") # 0xff27bb3a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_lifetime))
data.write(b'kW\x1b\xa5') # 0x6b571ba5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_collision_time))
data.write(b'P\x05\x1a\x17') # 0x50051a17
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_end_percentage))
data.write(b'cS\xc4\t') # 0x6353c409
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_start_percentage))
data.write(b':V4\xd8') # 0x3a5634d8
data.write(b'\x00\x10') # size
self.start_color.to_stream(data)
data.write(b'|n\xbe\x98') # 0x7c6ebe98
data.write(b'\x00\x10') # size
self.middle_color.to_stream(data)
data.write(b'Z\xf5\x86}') # 0x5af5867d
data.write(b'\x00\x10') # size
self.end_color.to_stream(data)
data.write(b'\xd7\x96\x90\xb4') # 0xd79690b4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd79690b4))
data.write(b'\x01E\xd0-') # 0x145d02d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0145d02d))
data.write(b'\x88n|\x9f') # 0x886e7c9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scale_start_percentage))
data.write(b'\x80\xc2*\n') # 0x80c22a0a
data.write(b'\x00\x0c') # size
self.final_scale.to_stream(data)
data.write(b'A\x7fJ\x91') # 0x417f4a91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x417f4a91))
data.write(b'\x16\xb7-I') # 0x16b72d49
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.friction))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b')_\x05\xb7') # 0x295f05b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_physics_threshold))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\xee\xdb\xb0~') # 0xeedbb07e
data.write(b'\x00\x0c') # size
self.model_pivot_point.to_stream(data)
data.write(b'\x93\xf8\xe0\xb0') # 0x93f8e0b0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.created_sound))
data.write(b'\xf1\x92Uv') # 0xf1925576
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_sound))
data.write(b'\x99\x12\x02\xc3') # 0x991202c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_bounce_sounds))
data.write(b'v\xc7\x95\x03') # 0x76c79503
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76c79503))
data.write(b'1\r\xfa\xc8') # 0x310dfac8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x310dfac8))
data.write(b'^\x9fR\x15') # 0x5e9f5215
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5e9f5215))
data.write(b'9t6\x18') # 0x39743618
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x39743618))
data.write(b'3\xe0\xfb\xb4') # 0x33e0fbb4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x33e0fbb4))
data.write(b'\xe8.~\xd7') # 0xe82e7ed7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe82e7ed7))
data.write(b'\x85^\xe2\x1b') # 0x855ee21b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x855ee21b))
data.write(b'G\x8d\n\xa3') # 0x478d0aa3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle_system1))
data.write(b'\x19\xa6\xf7\x1f') # 0x19a6f71f
data.write(b'\x00\x0c') # size
self.particle_system1_scale.to_stream(data)
data.write(b';\x03\xa0\x1e') # 0x3b03a01e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_uses_global_translation))
data.write(b'\xdb\x1f\xa6\x1c') # 0xdb1fa61c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_uses_global_orientation))
data.write(b';\xdd/\xed') # 0x3bdd2fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_wait_for_particles_to_die))
data.write(b'\xf5\xddF\x90') # 0xf5dd4690
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.particle_system1_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc1\x19x\r') # 0xc119780d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle_system2))
data.write(b'n8%\xef') # 0x6e3825ef
data.write(b'\x00\x0c') # size
self.particle_system2_scale.to_stream(data)
data.write(b'\xc9TM\xe6') # 0xc9544de6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_uses_global_translation))
data.write(b')HK\xe4') # 0x29484be4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_uses_global_orientation))
data.write(b'\xc9\x8a\xc2\x15') # 0xc98ac215
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_wait_for_particles_to_die))
data.write(b'<\xe9]\x9d') # 0x3ce95d9d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.particle_system2_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!|7\xc2') # 0x217c37c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_particle_effect))
data.write(b'`\xd6\xbf\x8e') # 0x60d6bf8e
data.write(b'\x00\x0c') # size
self.bounce_particle_scale.to_stream(data)
data.write(b'\xceY\xeb\xff') # 0xce59ebff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bounce_effect_transform.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b',{\x18\xdd') # 0x2c7b18dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_collider))
data.write(b'\xe7;\x9e\xb0') # 0xe73b9eb0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe73b9eb0))
data.write(b'\r\x7f\xadU') # 0xd7fad55
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.die_on_collision))
data.write(b'\x87#I\x8a') # 0x8723498a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8723498a))
data.write(b'\x0f,g>') # 0xf2c673e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x0f2c673e))
data.write(b'U\xd8\xac\xe3') # 0x55d8ace3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.collide_with_characters))
data.write(b'\x8e\xc6\x8a\x96') # 0x8ec68a96
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8ec68a96))
data.write(b'\x9b\xd9C&') # 0x9bd94326
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_bounce_speed_x))
data.write(b'P\x85\x90\x83') # 0x50859083
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_bounce_speed_y))
data.write(b'\xbf\xd8*\x19') # 0xbfd82a19
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbfd82a19))
data.write(b'r=B\xd6') # 0x723d42d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x723d42d6))
data.write(b'N\xdb\x1d\x0e') # 0x4edb1d0e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4edb1d0e))
data.write(b'\xbfIbs') # 0xbf496273
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbf496273))
data.write(b'\xf8<\x1c\x1f') # 0xf83c1c1f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf83c1c1f))
data.write(b'\x88\xb1\xafF') # 0x88b1af46
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x88b1af46))
data.write(b'\xa6\xaa\x06\xd5') # 0xa6aa06d5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_in_foreground))
data.write(b'27^\x0e') # 0x32375e0e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_silhouette))
data.write(b'\xe5\xec\xed\x02') # 0xe5eced02
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe5eced02))
@classmethod
def from_json(cls, data: dict):
return cls(
cone_spread_yaw=data['cone_spread_yaw'],
cone_spread_pitch=data['cone_spread_pitch'],
initial_direction=Vector.from_json(data['initial_direction']),
position_offset=Vector.from_json(data['position_offset']),
transform_position_offset=data['transform_position_offset'],
minimum_speed=data['minimum_speed'],
maximum_speed=data['maximum_speed'],
minimum_spin_speed=Vector.from_json(data['minimum_spin_speed']),
maximum_spin_speed=Vector.from_json(data['maximum_spin_speed']),
minimum_lifetime=data['minimum_lifetime'],
maximum_lifetime=data['maximum_lifetime'],
disable_collision_time=data['disable_collision_time'],
fade_in_end_percentage=data['fade_in_end_percentage'],
fade_out_start_percentage=data['fade_out_start_percentage'],
start_color=Color.from_json(data['start_color']),
middle_color=Color.from_json(data['middle_color']),
end_color=Color.from_json(data['end_color']),
unknown_0xd79690b4=data['unknown_0xd79690b4'],
unknown_0x0145d02d=data['unknown_0x0145d02d'],
scale_start_percentage=data['scale_start_percentage'],
final_scale=Vector.from_json(data['final_scale']),
unknown_0x417f4a91=data['unknown_0x417f4a91'],
friction=data['friction'],
gravity=data['gravity'],
disable_physics_threshold=data['disable_physics_threshold'],
model=data['model'],
model_pivot_point=Vector.from_json(data['model_pivot_point']),
created_sound=data['created_sound'],
bounce_sound=data['bounce_sound'],
max_bounce_sounds=data['max_bounce_sounds'],
unknown_0x76c79503=data['unknown_0x76c79503'],
unknown_0x310dfac8=data['unknown_0x310dfac8'],
unknown_0x5e9f5215=data['unknown_0x5e9f5215'],
unknown_0x39743618=data['unknown_0x39743618'],
unknown_0x33e0fbb4=data['unknown_0x33e0fbb4'],
unknown_0xe82e7ed7=data['unknown_0xe82e7ed7'],
unknown_0x855ee21b=data['unknown_0x855ee21b'],
particle_system1=data['particle_system1'],
particle_system1_scale=Vector.from_json(data['particle_system1_scale']),
particle_system1_uses_global_translation=data['particle_system1_uses_global_translation'],
particle_system1_uses_global_orientation=data['particle_system1_uses_global_orientation'],
particle_system1_wait_for_particles_to_die=data['particle_system1_wait_for_particles_to_die'],
particle_system1_orientation=DebrisPropertiesOrientationEnum.from_json(data['particle_system1_orientation']),
particle_system2=data['particle_system2'],
particle_system2_scale=Vector.from_json(data['particle_system2_scale']),
particle_system2_uses_global_translation=data['particle_system2_uses_global_translation'],
particle_system2_uses_global_orientation=data['particle_system2_uses_global_orientation'],
particle_system2_wait_for_particles_to_die=data['particle_system2_wait_for_particles_to_die'],
particle_system2_orientation=DebrisPropertiesOrientationEnum.from_json(data['particle_system2_orientation']),
bounce_particle_effect=data['bounce_particle_effect'],
bounce_particle_scale=Vector.from_json(data['bounce_particle_scale']),
bounce_effect_transform=UnknownStruct17.from_json(data['bounce_effect_transform']),
is_collider=data['is_collider'],
unknown_0xe73b9eb0=data['unknown_0xe73b9eb0'],
die_on_collision=data['die_on_collision'],
unknown_0x8723498a=data['unknown_0x8723498a'],
unknown_0x0f2c673e=data['unknown_0x0f2c673e'],
collide_with_characters=data['collide_with_characters'],
unknown_0x8ec68a96=data['unknown_0x8ec68a96'],
fixed_bounce_speed_x=data['fixed_bounce_speed_x'],
fixed_bounce_speed_y=data['fixed_bounce_speed_y'],
unknown_0xbfd82a19=data['unknown_0xbfd82a19'],
unknown_0x723d42d6=data['unknown_0x723d42d6'],
unknown_0x4edb1d0e=data['unknown_0x4edb1d0e'],
unknown_0xbf496273=data['unknown_0xbf496273'],
unknown_0xf83c1c1f=data['unknown_0xf83c1c1f'],
unknown_0x88b1af46=data['unknown_0x88b1af46'],
render_in_foreground=data['render_in_foreground'],
allow_silhouette=data['allow_silhouette'],
unknown_0xe5eced02=data['unknown_0xe5eced02'],
)
def to_json(self) -> dict:
return {
'cone_spread_yaw': self.cone_spread_yaw,
'cone_spread_pitch': self.cone_spread_pitch,
'initial_direction': self.initial_direction.to_json(),
'position_offset': self.position_offset.to_json(),
'transform_position_offset': self.transform_position_offset,
'minimum_speed': self.minimum_speed,
'maximum_speed': self.maximum_speed,
'minimum_spin_speed': self.minimum_spin_speed.to_json(),
'maximum_spin_speed': self.maximum_spin_speed.to_json(),
'minimum_lifetime': self.minimum_lifetime,
'maximum_lifetime': self.maximum_lifetime,
'disable_collision_time': self.disable_collision_time,
'fade_in_end_percentage': self.fade_in_end_percentage,
'fade_out_start_percentage': self.fade_out_start_percentage,
'start_color': self.start_color.to_json(),
'middle_color': self.middle_color.to_json(),
'end_color': self.end_color.to_json(),
'unknown_0xd79690b4': self.unknown_0xd79690b4,
'unknown_0x0145d02d': self.unknown_0x0145d02d,
'scale_start_percentage': self.scale_start_percentage,
'final_scale': self.final_scale.to_json(),
'unknown_0x417f4a91': self.unknown_0x417f4a91,
'friction': self.friction,
'gravity': self.gravity,
'disable_physics_threshold': self.disable_physics_threshold,
'model': self.model,
'model_pivot_point': self.model_pivot_point.to_json(),
'created_sound': self.created_sound,
'bounce_sound': self.bounce_sound,
'max_bounce_sounds': self.max_bounce_sounds,
'unknown_0x76c79503': self.unknown_0x76c79503,
'unknown_0x310dfac8': self.unknown_0x310dfac8,
'unknown_0x5e9f5215': self.unknown_0x5e9f5215,
'unknown_0x39743618': self.unknown_0x39743618,
'unknown_0x33e0fbb4': self.unknown_0x33e0fbb4,
'unknown_0xe82e7ed7': self.unknown_0xe82e7ed7,
'unknown_0x855ee21b': self.unknown_0x855ee21b,
'particle_system1': self.particle_system1,
'particle_system1_scale': self.particle_system1_scale.to_json(),
'particle_system1_uses_global_translation': self.particle_system1_uses_global_translation,
'particle_system1_uses_global_orientation': self.particle_system1_uses_global_orientation,
'particle_system1_wait_for_particles_to_die': self.particle_system1_wait_for_particles_to_die,
'particle_system1_orientation': self.particle_system1_orientation.to_json(),
'particle_system2': self.particle_system2,
'particle_system2_scale': self.particle_system2_scale.to_json(),
'particle_system2_uses_global_translation': self.particle_system2_uses_global_translation,
'particle_system2_uses_global_orientation': self.particle_system2_uses_global_orientation,
'particle_system2_wait_for_particles_to_die': self.particle_system2_wait_for_particles_to_die,
'particle_system2_orientation': self.particle_system2_orientation.to_json(),
'bounce_particle_effect': self.bounce_particle_effect,
'bounce_particle_scale': self.bounce_particle_scale.to_json(),
'bounce_effect_transform': self.bounce_effect_transform.to_json(),
'is_collider': self.is_collider,
'unknown_0xe73b9eb0': self.unknown_0xe73b9eb0,
'die_on_collision': self.die_on_collision,
'unknown_0x8723498a': self.unknown_0x8723498a,
'unknown_0x0f2c673e': self.unknown_0x0f2c673e,
'collide_with_characters': self.collide_with_characters,
'unknown_0x8ec68a96': self.unknown_0x8ec68a96,
'fixed_bounce_speed_x': self.fixed_bounce_speed_x,
'fixed_bounce_speed_y': self.fixed_bounce_speed_y,
'unknown_0xbfd82a19': self.unknown_0xbfd82a19,
'unknown_0x723d42d6': self.unknown_0x723d42d6,
'unknown_0x4edb1d0e': self.unknown_0x4edb1d0e,
'unknown_0xbf496273': self.unknown_0xbf496273,
'unknown_0xf83c1c1f': self.unknown_0xf83c1c1f,
'unknown_0x88b1af46': self.unknown_0x88b1af46,
'render_in_foreground': self.render_in_foreground,
'allow_silhouette': self.allow_silhouette,
'unknown_0xe5eced02': self.unknown_0xe5eced02,
}
def _decode_cone_spread_yaw(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cone_spread_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_direction(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_position_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_transform_position_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_speed(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]
def _decode_minimum_spin_speed(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_maximum_spin_speed(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_minimum_lifetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_lifetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disable_collision_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_end_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_middle_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_end_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0xd79690b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x0145d02d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_final_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x417f4a91(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_friction(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_disable_physics_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_model_pivot_point(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_created_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_max_bounce_sounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x76c79503(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x310dfac8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5e9f5215(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x39743618(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x33e0fbb4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe82e7ed7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x855ee21b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_particle_system1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_particle_system1_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system1_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_uses_global_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_orientation(data: typing.BinaryIO, property_size: int):
return DebrisPropertiesOrientationEnum.from_stream(data, property_size)
def _decode_particle_system2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_particle_system2_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system2_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_uses_global_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_orientation(data: typing.BinaryIO, property_size: int):
return DebrisPropertiesOrientationEnum.from_stream(data, property_size)
def _decode_bounce_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bounce_particle_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_bounce_effect_transform(data: typing.BinaryIO, property_size: int):
return UnknownStruct17.from_stream(data, property_size)
def _decode_is_collider(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe73b9eb0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_die_on_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x8723498a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x0f2c673e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_collide_with_characters(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x8ec68a96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fixed_bounce_speed_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fixed_bounce_speed_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbfd82a19(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x723d42d6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4edb1d0e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbf496273(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf83c1c1f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x88b1af46(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_in_foreground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_silhouette(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe5eced02(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]]] = {
0x5c3c4a57: ('cone_spread_yaw', _decode_cone_spread_yaw),
0xa79fc55f: ('cone_spread_pitch', _decode_cone_spread_pitch),
0x1a0dfe6: ('initial_direction', _decode_initial_direction),
0xef90f09d: ('position_offset', _decode_position_offset),
0xc4b1e6a1: ('transform_position_offset', _decode_transform_position_offset),
0x185263e: ('minimum_speed', _decode_minimum_speed),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
0xf78c8ac7: ('minimum_spin_speed', _decode_minimum_spin_speed),
0xb69bb541: ('maximum_spin_speed', _decode_maximum_spin_speed),
0xd6594622: ('minimum_lifetime', _decode_minimum_lifetime),
0xff27bb3a: ('maximum_lifetime', _decode_maximum_lifetime),
0x6b571ba5: ('disable_collision_time', _decode_disable_collision_time),
0x50051a17: ('fade_in_end_percentage', _decode_fade_in_end_percentage),
0x6353c409: ('fade_out_start_percentage', _decode_fade_out_start_percentage),
0x3a5634d8: ('start_color', _decode_start_color),
0x7c6ebe98: ('middle_color', _decode_middle_color),
0x5af5867d: ('end_color', _decode_end_color),
0xd79690b4: ('unknown_0xd79690b4', _decode_unknown_0xd79690b4),
0x145d02d: ('unknown_0x0145d02d', _decode_unknown_0x0145d02d),
0x886e7c9f: ('scale_start_percentage', _decode_scale_start_percentage),
0x80c22a0a: ('final_scale', _decode_final_scale),
0x417f4a91: ('unknown_0x417f4a91', _decode_unknown_0x417f4a91),
0x16b72d49: ('friction', _decode_friction),
0x2f2ae3e5: ('gravity', _decode_gravity),
0x295f05b7: ('disable_physics_threshold', _decode_disable_physics_threshold),
0xc27ffa8f: ('model', _decode_model),
0xeedbb07e: ('model_pivot_point', _decode_model_pivot_point),
0x93f8e0b0: ('created_sound', _decode_created_sound),
0xf1925576: ('bounce_sound', _decode_bounce_sound),
0x991202c3: ('max_bounce_sounds', _decode_max_bounce_sounds),
0x76c79503: ('unknown_0x76c79503', _decode_unknown_0x76c79503),
0x310dfac8: ('unknown_0x310dfac8', _decode_unknown_0x310dfac8),
0x5e9f5215: ('unknown_0x5e9f5215', _decode_unknown_0x5e9f5215),
0x39743618: ('unknown_0x39743618', _decode_unknown_0x39743618),
0x33e0fbb4: ('unknown_0x33e0fbb4', _decode_unknown_0x33e0fbb4),
0xe82e7ed7: ('unknown_0xe82e7ed7', _decode_unknown_0xe82e7ed7),
0x855ee21b: ('unknown_0x855ee21b', _decode_unknown_0x855ee21b),
0x478d0aa3: ('particle_system1', _decode_particle_system1),
0x19a6f71f: ('particle_system1_scale', _decode_particle_system1_scale),
0x3b03a01e: ('particle_system1_uses_global_translation', _decode_particle_system1_uses_global_translation),
0xdb1fa61c: ('particle_system1_uses_global_orientation', _decode_particle_system1_uses_global_orientation),
0x3bdd2fed: ('particle_system1_wait_for_particles_to_die', _decode_particle_system1_wait_for_particles_to_die),
0xf5dd4690: ('particle_system1_orientation', _decode_particle_system1_orientation),
0xc119780d: ('particle_system2', _decode_particle_system2),
0x6e3825ef: ('particle_system2_scale', _decode_particle_system2_scale),
0xc9544de6: ('particle_system2_uses_global_translation', _decode_particle_system2_uses_global_translation),
0x29484be4: ('particle_system2_uses_global_orientation', _decode_particle_system2_uses_global_orientation),
0xc98ac215: ('particle_system2_wait_for_particles_to_die', _decode_particle_system2_wait_for_particles_to_die),
0x3ce95d9d: ('particle_system2_orientation', _decode_particle_system2_orientation),
0x217c37c2: ('bounce_particle_effect', _decode_bounce_particle_effect),
0x60d6bf8e: ('bounce_particle_scale', _decode_bounce_particle_scale),
0xce59ebff: ('bounce_effect_transform', _decode_bounce_effect_transform),
0x2c7b18dd: ('is_collider', _decode_is_collider),
0xe73b9eb0: ('unknown_0xe73b9eb0', _decode_unknown_0xe73b9eb0),
0xd7fad55: ('die_on_collision', _decode_die_on_collision),
0x8723498a: ('unknown_0x8723498a', _decode_unknown_0x8723498a),
0xf2c673e: ('unknown_0x0f2c673e', _decode_unknown_0x0f2c673e),
0x55d8ace3: ('collide_with_characters', _decode_collide_with_characters),
0x8ec68a96: ('unknown_0x8ec68a96', _decode_unknown_0x8ec68a96),
0x9bd94326: ('fixed_bounce_speed_x', _decode_fixed_bounce_speed_x),
0x50859083: ('fixed_bounce_speed_y', _decode_fixed_bounce_speed_y),
0xbfd82a19: ('unknown_0xbfd82a19', _decode_unknown_0xbfd82a19),
0x723d42d6: ('unknown_0x723d42d6', _decode_unknown_0x723d42d6),
0x4edb1d0e: ('unknown_0x4edb1d0e', _decode_unknown_0x4edb1d0e),
0xbf496273: ('unknown_0xbf496273', _decode_unknown_0xbf496273),
0xf83c1c1f: ('unknown_0xf83c1c1f', _decode_unknown_0xf83c1c1f),
0x88b1af46: ('unknown_0x88b1af46', _decode_unknown_0x88b1af46),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
0x32375e0e: ('allow_silhouette', _decode_allow_silhouette),
0xe5eced02: ('unknown_0xe5eced02', _decode_unknown_0xe5eced02),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DebrisProperties.py | 0.733833 | 0.214609 | DebrisProperties.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.Vector import Vector
@dataclasses.dataclass()
class ReactiveActorBehavior(BaseProperty):
triggering_behavior: enums.TriggeringBehavior = dataclasses.field(default=enums.TriggeringBehavior.Unknown1)
player: bool = dataclasses.field(default=False)
rambi: bool = dataclasses.field(default=False)
generic_creature: bool = dataclasses.field(default=False)
actor: bool = dataclasses.field(default=False)
unknown_0xbb0ee668: int = dataclasses.field(default=0)
repeat_delay: float = dataclasses.field(default=0.0)
detection_radius: float = dataclasses.field(default=1.0)
unknown_0x8ffefc1e: 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\t') # 9 properties
data.write(b'\xde\x87Tj') # 0xde87546a
data.write(b'\x00\x04') # size
self.triggering_behavior.to_stream(data)
data.write(b'\xd5i\x92d') # 0xd5699264
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player))
data.write(b'\x16\xa9]B') # 0x16a95d42
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rambi))
data.write(b'\x07\x93\xa3\xf7') # 0x793a3f7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.generic_creature))
data.write(b'\x98)H\xdb') # 0x982948db
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.actor))
data.write(b'\xbb\x0e\xe6h') # 0xbb0ee668
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xbb0ee668))
data.write(b'!1\x1d\xce') # 0x21311dce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.repeat_delay))
data.write(b'!\xcd\xcf!') # 0x21cdcf21
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_radius))
data.write(b'\x8f\xfe\xfc\x1e') # 0x8ffefc1e
data.write(b'\x00\x0c') # size
self.unknown_0x8ffefc1e.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
triggering_behavior=enums.TriggeringBehavior.from_json(data['triggering_behavior']),
player=data['player'],
rambi=data['rambi'],
generic_creature=data['generic_creature'],
actor=data['actor'],
unknown_0xbb0ee668=data['unknown_0xbb0ee668'],
repeat_delay=data['repeat_delay'],
detection_radius=data['detection_radius'],
unknown_0x8ffefc1e=Vector.from_json(data['unknown_0x8ffefc1e']),
)
def to_json(self) -> dict:
return {
'triggering_behavior': self.triggering_behavior.to_json(),
'player': self.player,
'rambi': self.rambi,
'generic_creature': self.generic_creature,
'actor': self.actor,
'unknown_0xbb0ee668': self.unknown_0xbb0ee668,
'repeat_delay': self.repeat_delay,
'detection_radius': self.detection_radius,
'unknown_0x8ffefc1e': self.unknown_0x8ffefc1e.to_json(),
}
def _decode_triggering_behavior(data: typing.BinaryIO, property_size: int):
return enums.TriggeringBehavior.from_stream(data)
def _decode_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rambi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_generic_creature(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_actor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbb0ee668(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_repeat_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8ffefc1e(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]]] = {
0xde87546a: ('triggering_behavior', _decode_triggering_behavior),
0xd5699264: ('player', _decode_player),
0x16a95d42: ('rambi', _decode_rambi),
0x793a3f7: ('generic_creature', _decode_generic_creature),
0x982948db: ('actor', _decode_actor),
0xbb0ee668: ('unknown_0xbb0ee668', _decode_unknown_0xbb0ee668),
0x21311dce: ('repeat_delay', _decode_repeat_delay),
0x21cdcf21: ('detection_radius', _decode_detection_radius),
0x8ffefc1e: ('unknown_0x8ffefc1e', _decode_unknown_0x8ffefc1e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ReactiveActorBehavior.py | 0.657648 | 0.331661 | ReactiveActorBehavior.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 BossHUD(BaseProperty):
boss_hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, 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\x01') # 1 properties
data.write(b'\x8bL\x10,') # 0x8b4c102c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.boss_hud_frame))
@classmethod
def from_json(cls, data: dict):
return cls(
boss_hud_frame=data['boss_hud_frame'],
)
def to_json(self) -> dict:
return {
'boss_hud_frame': self.boss_hud_frame,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8b4c102c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BossHUD]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(14))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return BossHUD(
dec[2],
)
def _decode_boss_hud_frame(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]]] = {
0x8b4c102c: ('boss_hud_frame', _decode_boss_hud_frame),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BossHUD.py | 0.577614 | 0.259644 | BossHUD.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
@dataclasses.dataclass()
class UnknownStruct63(BaseProperty):
unknown_0x348c9d90: float = dataclasses.field(default=20.0)
flight_sound_deceleration_k: float = dataclasses.field(default=1.0)
flight_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
flight_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
flight_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
flight_sound_volume: Spline = dataclasses.field(default_factory=Spline)
caud: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xbd894993: Spline = dataclasses.field(default_factory=Spline)
flight_sound2_pitch: Spline = dataclasses.field(default_factory=Spline)
flight_sound2_volume: Spline = dataclasses.field(default_factory=Spline)
hit_player_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
swoop_interrupted_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\x0c') # 12 properties
data.write(b'4\x8c\x9d\x90') # 0x348c9d90
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x348c9d90))
data.write(b'z}\xf6\xe3') # 0x7a7df6e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flight_sound_deceleration_k))
data.write(b'\xe1\xe6k$') # 0xe1e66b24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flight_sound))
data.write(b'\xb4\x13\xc4_') # 0xb413c45f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_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'v\xc7FL') # 0x76c7464c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_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'\x10\xe0Z\xaf') # 0x10e05aaf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xc2\xf5\xf6') # 0xb0c2f5f6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud))
data.write(b'\xbd\x89I\x93') # 0xbd894993
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xbd894993.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05)\x1e\xf7') # 0x5291ef7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound2_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'L \xde\xf3') # 0x4c20def3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound2_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%\x9c\t9') # 0x259c0939
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hit_player_sound))
data.write(b'\xbe_\x11\x8d') # 0xbe5f118d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.swoop_interrupted_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x348c9d90=data['unknown_0x348c9d90'],
flight_sound_deceleration_k=data['flight_sound_deceleration_k'],
flight_sound=data['flight_sound'],
flight_sound_low_pass_filter=Spline.from_json(data['flight_sound_low_pass_filter']),
flight_sound_pitch=Spline.from_json(data['flight_sound_pitch']),
flight_sound_volume=Spline.from_json(data['flight_sound_volume']),
caud=data['caud'],
unknown_0xbd894993=Spline.from_json(data['unknown_0xbd894993']),
flight_sound2_pitch=Spline.from_json(data['flight_sound2_pitch']),
flight_sound2_volume=Spline.from_json(data['flight_sound2_volume']),
hit_player_sound=data['hit_player_sound'],
swoop_interrupted_sound=data['swoop_interrupted_sound'],
)
def to_json(self) -> dict:
return {
'unknown_0x348c9d90': self.unknown_0x348c9d90,
'flight_sound_deceleration_k': self.flight_sound_deceleration_k,
'flight_sound': self.flight_sound,
'flight_sound_low_pass_filter': self.flight_sound_low_pass_filter.to_json(),
'flight_sound_pitch': self.flight_sound_pitch.to_json(),
'flight_sound_volume': self.flight_sound_volume.to_json(),
'caud': self.caud,
'unknown_0xbd894993': self.unknown_0xbd894993.to_json(),
'flight_sound2_pitch': self.flight_sound2_pitch.to_json(),
'flight_sound2_volume': self.flight_sound2_volume.to_json(),
'hit_player_sound': self.hit_player_sound,
'swoop_interrupted_sound': self.swoop_interrupted_sound,
}
def _decode_unknown_0x348c9d90(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_sound_deceleration_k(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flight_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_caud(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xbd894993(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound2_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound2_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_hit_player_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_swoop_interrupted_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]]] = {
0x348c9d90: ('unknown_0x348c9d90', _decode_unknown_0x348c9d90),
0x7a7df6e3: ('flight_sound_deceleration_k', _decode_flight_sound_deceleration_k),
0xe1e66b24: ('flight_sound', _decode_flight_sound),
0xb413c45f: ('flight_sound_low_pass_filter', _decode_flight_sound_low_pass_filter),
0x76c7464c: ('flight_sound_pitch', _decode_flight_sound_pitch),
0x10e05aaf: ('flight_sound_volume', _decode_flight_sound_volume),
0xb0c2f5f6: ('caud', _decode_caud),
0xbd894993: ('unknown_0xbd894993', _decode_unknown_0xbd894993),
0x5291ef7: ('flight_sound2_pitch', _decode_flight_sound2_pitch),
0x4c20def3: ('flight_sound2_volume', _decode_flight_sound2_volume),
0x259c0939: ('hit_player_sound', _decode_hit_player_sound),
0xbe5f118d: ('swoop_interrupted_sound', _decode_swoop_interrupted_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct63.py | 0.561455 | 0.253093 | UnknownStruct63.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 UnknownStruct269(BaseProperty):
move: bool = dataclasses.field(default=True)
roll: bool = dataclasses.field(default=True)
ground_pound: 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\x03') # 3 properties
data.write(b'\xad\xd74\xc9') # 0xadd734c9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.move))
data.write(b'\xa7\x11T\xc2') # 0xa71154c2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.roll))
data.write(b'\xd2SE\xe8') # 0xd25345e8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ground_pound))
@classmethod
def from_json(cls, data: dict):
return cls(
move=data['move'],
roll=data['roll'],
ground_pound=data['ground_pound'],
)
def to_json(self) -> dict:
return {
'move': self.move,
'roll': self.roll,
'ground_pound': self.ground_pound,
}
_FAST_FORMAT = None
_FAST_IDS = (0xadd734c9, 0xa71154c2, 0xd25345e8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct269]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(21))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct269(
dec[2],
dec[5],
dec[8],
)
def _decode_move(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_roll(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ground_pound(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]]] = {
0xadd734c9: ('move', _decode_move),
0xa71154c2: ('roll', _decode_roll),
0xd25345e8: ('ground_pound', _decode_ground_pound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct269.py | 0.606498 | 0.310681 | UnknownStruct269.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.UnknownStruct253 import UnknownStruct253
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct50 import UnknownStruct50
@dataclasses.dataclass()
class RobotChickenStructB(BaseProperty):
attack_type: enums.AttackType = dataclasses.field(default=enums.AttackType.Unknown1)
unknown_0x968337ab: int = dataclasses.field(default=1)
unknown_0x8308e359: int = dataclasses.field(default=1)
unknown_struct253: UnknownStruct253 = dataclasses.field(default_factory=UnknownStruct253)
unknown_0x154a2c64: UnknownStruct253 = dataclasses.field(default_factory=UnknownStruct253)
unknown_struct50_0x634fddd1: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_0xd1989e0d: UnknownStruct253 = dataclasses.field(default_factory=UnknownStruct253)
unknown_0x7887f42d: UnknownStruct253 = dataclasses.field(default_factory=UnknownStruct253)
unknown_0xb29207a6: UnknownStruct253 = dataclasses.field(default_factory=UnknownStruct253)
unknown_struct50_0xb4c4fd1c: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb61afa3b: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb7af0726: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb3a6f475: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb2130968: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb0cd0e4f: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb178f352: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb8dee8e9: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb96b15f4: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0xb7a4789f: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x4508eb0e: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x47d6ec29: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x46631134: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x426ae267: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x43df1f7a: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x4101185d: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x40b4e540: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x4912fefb: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x48a703e6: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x44ecc5c1: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
unknown_struct50_0x468b1161: UnknownStruct50 = dataclasses.field(default_factory=UnknownStruct50)
@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'\x07\xd99\xa1') # 0x7d939a1
data.write(b'\x00\x04') # size
self.attack_type.to_stream(data)
data.write(b'\x96\x837\xab') # 0x968337ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x968337ab))
data.write(b'\x83\x08\xe3Y') # 0x8308e359
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8308e359))
data.write(b'\xc6\x9c\xca\xad') # 0xc69ccaad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct253.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15J,d') # 0x154a2c64
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x154a2c64.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'cO\xdd\xd1') # 0x634fddd1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x634fddd1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1\x98\x9e\r') # 0xd1989e0d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xd1989e0d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\x87\xf4-') # 0x7887f42d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7887f42d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2\x92\x07\xa6') # 0xb29207a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb29207a6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\xc4\xfd\x1c') # 0xb4c4fd1c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb4c4fd1c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6\x1a\xfa;') # 0xb61afa3b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb61afa3b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb7\xaf\x07&') # 0xb7af0726
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb7af0726.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\xa6\xf4u') # 0xb3a6f475
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb3a6f475.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2\x13\th') # 0xb2130968
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb2130968.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xcd\x0eO') # 0xb0cd0e4f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb0cd0e4f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb1x\xf3R') # 0xb178f352
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb178f352.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8\xde\xe8\xe9') # 0xb8dee8e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb8dee8e9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9k\x15\xf4') # 0xb96b15f4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb96b15f4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb7\xa4x\x9f') # 0xb7a4789f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0xb7a4789f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\x08\xeb\x0e') # 0x4508eb0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x4508eb0e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'G\xd6\xec)') # 0x47d6ec29
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x47d6ec29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Fc\x114') # 0x46631134
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x46631134.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Bj\xe2g') # 0x426ae267
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x426ae267.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\xdf\x1fz') # 0x43df1f7a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x43df1f7a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A\x01\x18]') # 0x4101185d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x4101185d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@\xb4\xe5@') # 0x40b4e540
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x40b4e540.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'I\x12\xfe\xfb') # 0x4912fefb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x4912fefb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'H\xa7\x03\xe6') # 0x48a703e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x48a703e6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D\xec\xc5\xc1') # 0x44ecc5c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x44ecc5c1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'F\x8b\x11a') # 0x468b1161
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct50_0x468b1161.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_type=enums.AttackType.from_json(data['attack_type']),
unknown_0x968337ab=data['unknown_0x968337ab'],
unknown_0x8308e359=data['unknown_0x8308e359'],
unknown_struct253=UnknownStruct253.from_json(data['unknown_struct253']),
unknown_0x154a2c64=UnknownStruct253.from_json(data['unknown_0x154a2c64']),
unknown_struct50_0x634fddd1=UnknownStruct50.from_json(data['unknown_struct50_0x634fddd1']),
unknown_0xd1989e0d=UnknownStruct253.from_json(data['unknown_0xd1989e0d']),
unknown_0x7887f42d=UnknownStruct253.from_json(data['unknown_0x7887f42d']),
unknown_0xb29207a6=UnknownStruct253.from_json(data['unknown_0xb29207a6']),
unknown_struct50_0xb4c4fd1c=UnknownStruct50.from_json(data['unknown_struct50_0xb4c4fd1c']),
unknown_struct50_0xb61afa3b=UnknownStruct50.from_json(data['unknown_struct50_0xb61afa3b']),
unknown_struct50_0xb7af0726=UnknownStruct50.from_json(data['unknown_struct50_0xb7af0726']),
unknown_struct50_0xb3a6f475=UnknownStruct50.from_json(data['unknown_struct50_0xb3a6f475']),
unknown_struct50_0xb2130968=UnknownStruct50.from_json(data['unknown_struct50_0xb2130968']),
unknown_struct50_0xb0cd0e4f=UnknownStruct50.from_json(data['unknown_struct50_0xb0cd0e4f']),
unknown_struct50_0xb178f352=UnknownStruct50.from_json(data['unknown_struct50_0xb178f352']),
unknown_struct50_0xb8dee8e9=UnknownStruct50.from_json(data['unknown_struct50_0xb8dee8e9']),
unknown_struct50_0xb96b15f4=UnknownStruct50.from_json(data['unknown_struct50_0xb96b15f4']),
unknown_struct50_0xb7a4789f=UnknownStruct50.from_json(data['unknown_struct50_0xb7a4789f']),
unknown_struct50_0x4508eb0e=UnknownStruct50.from_json(data['unknown_struct50_0x4508eb0e']),
unknown_struct50_0x47d6ec29=UnknownStruct50.from_json(data['unknown_struct50_0x47d6ec29']),
unknown_struct50_0x46631134=UnknownStruct50.from_json(data['unknown_struct50_0x46631134']),
unknown_struct50_0x426ae267=UnknownStruct50.from_json(data['unknown_struct50_0x426ae267']),
unknown_struct50_0x43df1f7a=UnknownStruct50.from_json(data['unknown_struct50_0x43df1f7a']),
unknown_struct50_0x4101185d=UnknownStruct50.from_json(data['unknown_struct50_0x4101185d']),
unknown_struct50_0x40b4e540=UnknownStruct50.from_json(data['unknown_struct50_0x40b4e540']),
unknown_struct50_0x4912fefb=UnknownStruct50.from_json(data['unknown_struct50_0x4912fefb']),
unknown_struct50_0x48a703e6=UnknownStruct50.from_json(data['unknown_struct50_0x48a703e6']),
unknown_struct50_0x44ecc5c1=UnknownStruct50.from_json(data['unknown_struct50_0x44ecc5c1']),
unknown_struct50_0x468b1161=UnknownStruct50.from_json(data['unknown_struct50_0x468b1161']),
)
def to_json(self) -> dict:
return {
'attack_type': self.attack_type.to_json(),
'unknown_0x968337ab': self.unknown_0x968337ab,
'unknown_0x8308e359': self.unknown_0x8308e359,
'unknown_struct253': self.unknown_struct253.to_json(),
'unknown_0x154a2c64': self.unknown_0x154a2c64.to_json(),
'unknown_struct50_0x634fddd1': self.unknown_struct50_0x634fddd1.to_json(),
'unknown_0xd1989e0d': self.unknown_0xd1989e0d.to_json(),
'unknown_0x7887f42d': self.unknown_0x7887f42d.to_json(),
'unknown_0xb29207a6': self.unknown_0xb29207a6.to_json(),
'unknown_struct50_0xb4c4fd1c': self.unknown_struct50_0xb4c4fd1c.to_json(),
'unknown_struct50_0xb61afa3b': self.unknown_struct50_0xb61afa3b.to_json(),
'unknown_struct50_0xb7af0726': self.unknown_struct50_0xb7af0726.to_json(),
'unknown_struct50_0xb3a6f475': self.unknown_struct50_0xb3a6f475.to_json(),
'unknown_struct50_0xb2130968': self.unknown_struct50_0xb2130968.to_json(),
'unknown_struct50_0xb0cd0e4f': self.unknown_struct50_0xb0cd0e4f.to_json(),
'unknown_struct50_0xb178f352': self.unknown_struct50_0xb178f352.to_json(),
'unknown_struct50_0xb8dee8e9': self.unknown_struct50_0xb8dee8e9.to_json(),
'unknown_struct50_0xb96b15f4': self.unknown_struct50_0xb96b15f4.to_json(),
'unknown_struct50_0xb7a4789f': self.unknown_struct50_0xb7a4789f.to_json(),
'unknown_struct50_0x4508eb0e': self.unknown_struct50_0x4508eb0e.to_json(),
'unknown_struct50_0x47d6ec29': self.unknown_struct50_0x47d6ec29.to_json(),
'unknown_struct50_0x46631134': self.unknown_struct50_0x46631134.to_json(),
'unknown_struct50_0x426ae267': self.unknown_struct50_0x426ae267.to_json(),
'unknown_struct50_0x43df1f7a': self.unknown_struct50_0x43df1f7a.to_json(),
'unknown_struct50_0x4101185d': self.unknown_struct50_0x4101185d.to_json(),
'unknown_struct50_0x40b4e540': self.unknown_struct50_0x40b4e540.to_json(),
'unknown_struct50_0x4912fefb': self.unknown_struct50_0x4912fefb.to_json(),
'unknown_struct50_0x48a703e6': self.unknown_struct50_0x48a703e6.to_json(),
'unknown_struct50_0x44ecc5c1': self.unknown_struct50_0x44ecc5c1.to_json(),
'unknown_struct50_0x468b1161': self.unknown_struct50_0x468b1161.to_json(),
}
def _decode_attack_type(data: typing.BinaryIO, property_size: int):
return enums.AttackType.from_stream(data)
def _decode_unknown_0x968337ab(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x8308e359(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct253(data: typing.BinaryIO, property_size: int):
return UnknownStruct253.from_stream(data, property_size)
def _decode_unknown_0x154a2c64(data: typing.BinaryIO, property_size: int):
return UnknownStruct253.from_stream(data, property_size)
def _decode_unknown_struct50_0x634fddd1(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_0xd1989e0d(data: typing.BinaryIO, property_size: int):
return UnknownStruct253.from_stream(data, property_size)
def _decode_unknown_0x7887f42d(data: typing.BinaryIO, property_size: int):
return UnknownStruct253.from_stream(data, property_size)
def _decode_unknown_0xb29207a6(data: typing.BinaryIO, property_size: int):
return UnknownStruct253.from_stream(data, property_size)
def _decode_unknown_struct50_0xb4c4fd1c(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb61afa3b(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb7af0726(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb3a6f475(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb2130968(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb0cd0e4f(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb178f352(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb8dee8e9(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb96b15f4(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0xb7a4789f(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x4508eb0e(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x47d6ec29(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x46631134(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x426ae267(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x43df1f7a(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x4101185d(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x40b4e540(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x4912fefb(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x48a703e6(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x44ecc5c1(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
def _decode_unknown_struct50_0x468b1161(data: typing.BinaryIO, property_size: int):
return UnknownStruct50.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7d939a1: ('attack_type', _decode_attack_type),
0x968337ab: ('unknown_0x968337ab', _decode_unknown_0x968337ab),
0x8308e359: ('unknown_0x8308e359', _decode_unknown_0x8308e359),
0xc69ccaad: ('unknown_struct253', _decode_unknown_struct253),
0x154a2c64: ('unknown_0x154a2c64', _decode_unknown_0x154a2c64),
0x634fddd1: ('unknown_struct50_0x634fddd1', _decode_unknown_struct50_0x634fddd1),
0xd1989e0d: ('unknown_0xd1989e0d', _decode_unknown_0xd1989e0d),
0x7887f42d: ('unknown_0x7887f42d', _decode_unknown_0x7887f42d),
0xb29207a6: ('unknown_0xb29207a6', _decode_unknown_0xb29207a6),
0xb4c4fd1c: ('unknown_struct50_0xb4c4fd1c', _decode_unknown_struct50_0xb4c4fd1c),
0xb61afa3b: ('unknown_struct50_0xb61afa3b', _decode_unknown_struct50_0xb61afa3b),
0xb7af0726: ('unknown_struct50_0xb7af0726', _decode_unknown_struct50_0xb7af0726),
0xb3a6f475: ('unknown_struct50_0xb3a6f475', _decode_unknown_struct50_0xb3a6f475),
0xb2130968: ('unknown_struct50_0xb2130968', _decode_unknown_struct50_0xb2130968),
0xb0cd0e4f: ('unknown_struct50_0xb0cd0e4f', _decode_unknown_struct50_0xb0cd0e4f),
0xb178f352: ('unknown_struct50_0xb178f352', _decode_unknown_struct50_0xb178f352),
0xb8dee8e9: ('unknown_struct50_0xb8dee8e9', _decode_unknown_struct50_0xb8dee8e9),
0xb96b15f4: ('unknown_struct50_0xb96b15f4', _decode_unknown_struct50_0xb96b15f4),
0xb7a4789f: ('unknown_struct50_0xb7a4789f', _decode_unknown_struct50_0xb7a4789f),
0x4508eb0e: ('unknown_struct50_0x4508eb0e', _decode_unknown_struct50_0x4508eb0e),
0x47d6ec29: ('unknown_struct50_0x47d6ec29', _decode_unknown_struct50_0x47d6ec29),
0x46631134: ('unknown_struct50_0x46631134', _decode_unknown_struct50_0x46631134),
0x426ae267: ('unknown_struct50_0x426ae267', _decode_unknown_struct50_0x426ae267),
0x43df1f7a: ('unknown_struct50_0x43df1f7a', _decode_unknown_struct50_0x43df1f7a),
0x4101185d: ('unknown_struct50_0x4101185d', _decode_unknown_struct50_0x4101185d),
0x40b4e540: ('unknown_struct50_0x40b4e540', _decode_unknown_struct50_0x40b4e540),
0x4912fefb: ('unknown_struct50_0x4912fefb', _decode_unknown_struct50_0x4912fefb),
0x48a703e6: ('unknown_struct50_0x48a703e6', _decode_unknown_struct50_0x48a703e6),
0x44ecc5c1: ('unknown_struct50_0x44ecc5c1', _decode_unknown_struct50_0x44ecc5c1),
0x468b1161: ('unknown_struct50_0x468b1161', _decode_unknown_struct50_0x468b1161),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RobotChickenStructB.py | 0.523908 | 0.153962 | RobotChickenStructB.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 DynamicLightFalloff(BaseProperty):
falloff_type: int = dataclasses.field(default=0)
falloff_rate: Spline = dataclasses.field(default_factory=Spline)
falloff_rate_duration: float = dataclasses.field(default=0.0)
falloff_rate_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\x04') # 4 properties
data.write(b'Em\xf2\x0c') # 0x456df20c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.falloff_type))
data.write(b'/|c\xa3') # 0x2f7c63a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.falloff_rate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1fh\x13\xf1') # 0x1f6813f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.falloff_rate_duration))
data.write(b'm2>\xa3') # 0x6d323ea3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.falloff_rate_loops))
@classmethod
def from_json(cls, data: dict):
return cls(
falloff_type=data['falloff_type'],
falloff_rate=Spline.from_json(data['falloff_rate']),
falloff_rate_duration=data['falloff_rate_duration'],
falloff_rate_loops=data['falloff_rate_loops'],
)
def to_json(self) -> dict:
return {
'falloff_type': self.falloff_type,
'falloff_rate': self.falloff_rate.to_json(),
'falloff_rate_duration': self.falloff_rate_duration,
'falloff_rate_loops': self.falloff_rate_loops,
}
def _decode_falloff_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_falloff_rate(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_falloff_rate_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_falloff_rate_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]]] = {
0x456df20c: ('falloff_type', _decode_falloff_type),
0x2f7c63a3: ('falloff_rate', _decode_falloff_rate),
0x1f6813f1: ('falloff_rate_duration', _decode_falloff_rate_duration),
0x6d323ea3: ('falloff_rate_loops', _decode_falloff_rate_loops),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DynamicLightFalloff.py | 0.634543 | 0.351812 | DynamicLightFalloff.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.RobotChickenFlyerStructA import RobotChickenFlyerStructA
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct260 import UnknownStruct260
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct261 import UnknownStruct261
@dataclasses.dataclass()
class UnknownStruct262(BaseProperty):
snap_to_spline: bool = dataclasses.field(default=True)
floor_height: float = dataclasses.field(default=0.0)
gravity: float = dataclasses.field(default=55.0)
acceleration: float = dataclasses.field(default=20.0)
deceleration: float = dataclasses.field(default=12.0)
maximum_speed: float = dataclasses.field(default=12.0)
unknown_0xe46e8d01: float = dataclasses.field(default=10.0)
use_player_crush: bool = dataclasses.field(default=False)
max_children: int = dataclasses.field(default=6)
child_spawn_time: float = dataclasses.field(default=2.0)
unknown_0xd2d92d71: int = dataclasses.field(default=9)
unknown_0x1cc6b88d: float = dataclasses.field(default=0.8700000047683716)
unknown_0x9605aad3: int = dataclasses.field(default=20)
unknown_0x806dc773: float = dataclasses.field(default=0.0)
unknown_0x101ed799: float = dataclasses.field(default=9.0)
unknown_0xbbd7c692: float = dataclasses.field(default=13.0)
robot_chicken_flyer_struct_a_0xe84aa51c: RobotChickenFlyerStructA = dataclasses.field(default_factory=RobotChickenFlyerStructA)
robot_chicken_flyer_struct_a_0xa152f46f: RobotChickenFlyerStructA = dataclasses.field(default_factory=RobotChickenFlyerStructA)
robot_chicken_flyer_struct_a_0x1f59e2c1: RobotChickenFlyerStructA = dataclasses.field(default_factory=RobotChickenFlyerStructA)
robot_chicken_flyer_struct_a_0xc4d0e557: RobotChickenFlyerStructA = dataclasses.field(default_factory=RobotChickenFlyerStructA)
unknown_struct260: UnknownStruct260 = dataclasses.field(default_factory=UnknownStruct260)
anim_grid: AnimGridModifierData = dataclasses.field(default_factory=AnimGridModifierData)
unknown_struct261: UnknownStruct261 = dataclasses.field(default_factory=UnknownStruct261)
@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'&\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'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))
data.write(b'\xe4n\x8d\x01') # 0xe46e8d01
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe46e8d01))
data.write(b'\xea\x05i\xd2') # 0xea0569d2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_player_crush))
data.write(b'\x8b\x12\xf3\xb0') # 0x8b12f3b0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_children))
data.write(b'h\xda\xe7\xe9') # 0x68dae7e9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.child_spawn_time))
data.write(b'\xd2\xd9-q') # 0xd2d92d71
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd2d92d71))
data.write(b'\x1c\xc6\xb8\x8d') # 0x1cc6b88d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1cc6b88d))
data.write(b'\x96\x05\xaa\xd3') # 0x9605aad3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x9605aad3))
data.write(b'\x80m\xc7s') # 0x806dc773
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x806dc773))
data.write(b'\x10\x1e\xd7\x99') # 0x101ed799
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x101ed799))
data.write(b'\xbb\xd7\xc6\x92') # 0xbbd7c692
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbbd7c692))
data.write(b'\xe8J\xa5\x1c') # 0xe84aa51c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_a_0xe84aa51c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1R\xf4o') # 0xa152f46f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_a_0xa152f46f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1fY\xe2\xc1') # 0x1f59e2c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_a_0x1f59e2c1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xd0\xe5W') # 0xc4d0e557
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_a_0xc4d0e557.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\x01\x1e\xc5') # 0xf8011ec5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct260.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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'B\x01Q\xf6') # 0x420151f6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct261.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'],
acceleration=data['acceleration'],
deceleration=data['deceleration'],
maximum_speed=data['maximum_speed'],
unknown_0xe46e8d01=data['unknown_0xe46e8d01'],
use_player_crush=data['use_player_crush'],
max_children=data['max_children'],
child_spawn_time=data['child_spawn_time'],
unknown_0xd2d92d71=data['unknown_0xd2d92d71'],
unknown_0x1cc6b88d=data['unknown_0x1cc6b88d'],
unknown_0x9605aad3=data['unknown_0x9605aad3'],
unknown_0x806dc773=data['unknown_0x806dc773'],
unknown_0x101ed799=data['unknown_0x101ed799'],
unknown_0xbbd7c692=data['unknown_0xbbd7c692'],
robot_chicken_flyer_struct_a_0xe84aa51c=RobotChickenFlyerStructA.from_json(data['robot_chicken_flyer_struct_a_0xe84aa51c']),
robot_chicken_flyer_struct_a_0xa152f46f=RobotChickenFlyerStructA.from_json(data['robot_chicken_flyer_struct_a_0xa152f46f']),
robot_chicken_flyer_struct_a_0x1f59e2c1=RobotChickenFlyerStructA.from_json(data['robot_chicken_flyer_struct_a_0x1f59e2c1']),
robot_chicken_flyer_struct_a_0xc4d0e557=RobotChickenFlyerStructA.from_json(data['robot_chicken_flyer_struct_a_0xc4d0e557']),
unknown_struct260=UnknownStruct260.from_json(data['unknown_struct260']),
anim_grid=AnimGridModifierData.from_json(data['anim_grid']),
unknown_struct261=UnknownStruct261.from_json(data['unknown_struct261']),
)
def to_json(self) -> dict:
return {
'snap_to_spline': self.snap_to_spline,
'floor_height': self.floor_height,
'gravity': self.gravity,
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'maximum_speed': self.maximum_speed,
'unknown_0xe46e8d01': self.unknown_0xe46e8d01,
'use_player_crush': self.use_player_crush,
'max_children': self.max_children,
'child_spawn_time': self.child_spawn_time,
'unknown_0xd2d92d71': self.unknown_0xd2d92d71,
'unknown_0x1cc6b88d': self.unknown_0x1cc6b88d,
'unknown_0x9605aad3': self.unknown_0x9605aad3,
'unknown_0x806dc773': self.unknown_0x806dc773,
'unknown_0x101ed799': self.unknown_0x101ed799,
'unknown_0xbbd7c692': self.unknown_0xbbd7c692,
'robot_chicken_flyer_struct_a_0xe84aa51c': self.robot_chicken_flyer_struct_a_0xe84aa51c.to_json(),
'robot_chicken_flyer_struct_a_0xa152f46f': self.robot_chicken_flyer_struct_a_0xa152f46f.to_json(),
'robot_chicken_flyer_struct_a_0x1f59e2c1': self.robot_chicken_flyer_struct_a_0x1f59e2c1.to_json(),
'robot_chicken_flyer_struct_a_0xc4d0e557': self.robot_chicken_flyer_struct_a_0xc4d0e557.to_json(),
'unknown_struct260': self.unknown_struct260.to_json(),
'anim_grid': self.anim_grid.to_json(),
'unknown_struct261': self.unknown_struct261.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_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]
def _decode_unknown_0xe46e8d01(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_player_crush(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_children(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_child_spawn_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd2d92d71(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x1cc6b88d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9605aad3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x806dc773(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x101ed799(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbbd7c692(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_robot_chicken_flyer_struct_a_0xe84aa51c(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructA.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_a_0xa152f46f(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructA.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_a_0x1f59e2c1(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructA.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_a_0xc4d0e557(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructA.from_stream(data, property_size)
def _decode_unknown_struct260(data: typing.BinaryIO, property_size: int):
return UnknownStruct260.from_stream(data, property_size)
def _decode_anim_grid(data: typing.BinaryIO, property_size: int):
return AnimGridModifierData.from_stream(data, property_size)
def _decode_unknown_struct261(data: typing.BinaryIO, property_size: int):
return UnknownStruct261.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),
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
0xe46e8d01: ('unknown_0xe46e8d01', _decode_unknown_0xe46e8d01),
0xea0569d2: ('use_player_crush', _decode_use_player_crush),
0x8b12f3b0: ('max_children', _decode_max_children),
0x68dae7e9: ('child_spawn_time', _decode_child_spawn_time),
0xd2d92d71: ('unknown_0xd2d92d71', _decode_unknown_0xd2d92d71),
0x1cc6b88d: ('unknown_0x1cc6b88d', _decode_unknown_0x1cc6b88d),
0x9605aad3: ('unknown_0x9605aad3', _decode_unknown_0x9605aad3),
0x806dc773: ('unknown_0x806dc773', _decode_unknown_0x806dc773),
0x101ed799: ('unknown_0x101ed799', _decode_unknown_0x101ed799),
0xbbd7c692: ('unknown_0xbbd7c692', _decode_unknown_0xbbd7c692),
0xe84aa51c: ('robot_chicken_flyer_struct_a_0xe84aa51c', _decode_robot_chicken_flyer_struct_a_0xe84aa51c),
0xa152f46f: ('robot_chicken_flyer_struct_a_0xa152f46f', _decode_robot_chicken_flyer_struct_a_0xa152f46f),
0x1f59e2c1: ('robot_chicken_flyer_struct_a_0x1f59e2c1', _decode_robot_chicken_flyer_struct_a_0x1f59e2c1),
0xc4d0e557: ('robot_chicken_flyer_struct_a_0xc4d0e557', _decode_robot_chicken_flyer_struct_a_0xc4d0e557),
0xf8011ec5: ('unknown_struct260', _decode_unknown_struct260),
0x68fd49ae: ('anim_grid', _decode_anim_grid),
0x420151f6: ('unknown_struct261', _decode_unknown_struct261),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct262.py | 0.638723 | 0.222341 | UnknownStruct262.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 CameraClip(BaseProperty):
near_clip_plane: float = dataclasses.field(default=0.20000000298023224)
far_clip_plane: float = dataclasses.field(default=750.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\x02') # 2 properties
data.write(b'\xf4\x81\x7f\x13') # 0xf4817f13
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.near_clip_plane))
data.write(b'\x84\xecJt') # 0x84ec4a74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_clip_plane))
@classmethod
def from_json(cls, data: dict):
return cls(
near_clip_plane=data['near_clip_plane'],
far_clip_plane=data['far_clip_plane'],
)
def to_json(self) -> dict:
return {
'near_clip_plane': self.near_clip_plane,
'far_clip_plane': self.far_clip_plane,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf4817f13, 0x84ec4a74)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraClip]:
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 CameraClip(
dec[2],
dec[5],
)
def _decode_near_clip_plane(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_clip_plane(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]]] = {
0xf4817f13: ('near_clip_plane', _decode_near_clip_plane),
0x84ec4a74: ('far_clip_plane', _decode_far_clip_plane),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraClip.py | 0.719088 | 0.385751 | CameraClip.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.UnknownStruct289 import UnknownStruct289
from retro_data_structures.properties.dkc_returns.archetypes.VolcanoBossBodyPartStructB import VolcanoBossBodyPartStructB
@dataclasses.dataclass()
class UnknownStruct290(BaseProperty):
unknown_struct289: UnknownStruct289 = dataclasses.field(default_factory=UnknownStruct289)
volcano_boss_body_part_struct_b_0xc3e3ef00: VolcanoBossBodyPartStructB = dataclasses.field(default_factory=VolcanoBossBodyPartStructB)
volcano_boss_body_part_struct_b_0xfa9b4240: VolcanoBossBodyPartStructB = dataclasses.field(default_factory=VolcanoBossBodyPartStructB)
volcano_boss_body_part_struct_b_0xedb32680: VolcanoBossBodyPartStructB = dataclasses.field(default_factory=VolcanoBossBodyPartStructB)
@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' \x8ci\xa5') # 0x208c69a5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct289.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3\xe3\xef\x00') # 0xc3e3ef00
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_b_0xc3e3ef00.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa\x9bB@') # 0xfa9b4240
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_b_0xfa9b4240.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xb3&\x80') # 0xedb32680
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_b_0xedb32680.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_struct289=UnknownStruct289.from_json(data['unknown_struct289']),
volcano_boss_body_part_struct_b_0xc3e3ef00=VolcanoBossBodyPartStructB.from_json(data['volcano_boss_body_part_struct_b_0xc3e3ef00']),
volcano_boss_body_part_struct_b_0xfa9b4240=VolcanoBossBodyPartStructB.from_json(data['volcano_boss_body_part_struct_b_0xfa9b4240']),
volcano_boss_body_part_struct_b_0xedb32680=VolcanoBossBodyPartStructB.from_json(data['volcano_boss_body_part_struct_b_0xedb32680']),
)
def to_json(self) -> dict:
return {
'unknown_struct289': self.unknown_struct289.to_json(),
'volcano_boss_body_part_struct_b_0xc3e3ef00': self.volcano_boss_body_part_struct_b_0xc3e3ef00.to_json(),
'volcano_boss_body_part_struct_b_0xfa9b4240': self.volcano_boss_body_part_struct_b_0xfa9b4240.to_json(),
'volcano_boss_body_part_struct_b_0xedb32680': self.volcano_boss_body_part_struct_b_0xedb32680.to_json(),
}
def _decode_unknown_struct289(data: typing.BinaryIO, property_size: int):
return UnknownStruct289.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_b_0xc3e3ef00(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructB.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_b_0xfa9b4240(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructB.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_b_0xedb32680(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x208c69a5: ('unknown_struct289', _decode_unknown_struct289),
0xc3e3ef00: ('volcano_boss_body_part_struct_b_0xc3e3ef00', _decode_volcano_boss_body_part_struct_b_0xc3e3ef00),
0xfa9b4240: ('volcano_boss_body_part_struct_b_0xfa9b4240', _decode_volcano_boss_body_part_struct_b_0xfa9b4240),
0xedb32680: ('volcano_boss_body_part_struct_b_0xedb32680', _decode_volcano_boss_body_part_struct_b_0xedb32680),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct290.py | 0.570331 | 0.336876 | UnknownStruct290.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.UnknownStruct53 import UnknownStruct53
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct54 import UnknownStruct54
@dataclasses.dataclass()
class UnknownStruct55(BaseProperty):
frequency: float = dataclasses.field(default=0.0)
unknown_struct54_0x8772cb7e: UnknownStruct54 = dataclasses.field(default_factory=UnknownStruct54)
unknown_struct54_0x3cadcc64: UnknownStruct54 = dataclasses.field(default_factory=UnknownStruct54)
number_of_choices: int = dataclasses.field(default=0)
unknown_struct53_0x5e856665: UnknownStruct53 = dataclasses.field(default_factory=UnknownStruct53)
unknown_struct53_0xed114ba6: UnknownStruct53 = dataclasses.field(default_factory=UnknownStruct53)
unknown_struct53_0x839d50e7: UnknownStruct53 = dataclasses.field(default_factory=UnknownStruct53)
unknown_struct53_0x51481661: UnknownStruct53 = dataclasses.field(default_factory=UnknownStruct53)
unknown_struct53_0x3fc40d20: UnknownStruct53 = dataclasses.field(default_factory=UnknownStruct53)
@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'\x98\xcb\xfe\xdc') # 0x98cbfedc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.frequency))
data.write(b'\x87r\xcb~') # 0x8772cb7e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct54_0x8772cb7e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<\xad\xccd') # 0x3cadcc64
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct54_0x3cadcc64.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91V\xba_') # 0x9156ba5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_choices))
data.write(b'^\x85fe') # 0x5e856665
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct53_0x5e856665.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\x11K\xa6') # 0xed114ba6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct53_0xed114ba6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x83\x9dP\xe7') # 0x839d50e7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct53_0x839d50e7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'QH\x16a') # 0x51481661
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct53_0x51481661.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'?\xc4\r ') # 0x3fc40d20
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct53_0x3fc40d20.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(
frequency=data['frequency'],
unknown_struct54_0x8772cb7e=UnknownStruct54.from_json(data['unknown_struct54_0x8772cb7e']),
unknown_struct54_0x3cadcc64=UnknownStruct54.from_json(data['unknown_struct54_0x3cadcc64']),
number_of_choices=data['number_of_choices'],
unknown_struct53_0x5e856665=UnknownStruct53.from_json(data['unknown_struct53_0x5e856665']),
unknown_struct53_0xed114ba6=UnknownStruct53.from_json(data['unknown_struct53_0xed114ba6']),
unknown_struct53_0x839d50e7=UnknownStruct53.from_json(data['unknown_struct53_0x839d50e7']),
unknown_struct53_0x51481661=UnknownStruct53.from_json(data['unknown_struct53_0x51481661']),
unknown_struct53_0x3fc40d20=UnknownStruct53.from_json(data['unknown_struct53_0x3fc40d20']),
)
def to_json(self) -> dict:
return {
'frequency': self.frequency,
'unknown_struct54_0x8772cb7e': self.unknown_struct54_0x8772cb7e.to_json(),
'unknown_struct54_0x3cadcc64': self.unknown_struct54_0x3cadcc64.to_json(),
'number_of_choices': self.number_of_choices,
'unknown_struct53_0x5e856665': self.unknown_struct53_0x5e856665.to_json(),
'unknown_struct53_0xed114ba6': self.unknown_struct53_0xed114ba6.to_json(),
'unknown_struct53_0x839d50e7': self.unknown_struct53_0x839d50e7.to_json(),
'unknown_struct53_0x51481661': self.unknown_struct53_0x51481661.to_json(),
'unknown_struct53_0x3fc40d20': self.unknown_struct53_0x3fc40d20.to_json(),
}
def _decode_frequency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct54_0x8772cb7e(data: typing.BinaryIO, property_size: int):
return UnknownStruct54.from_stream(data, property_size)
def _decode_unknown_struct54_0x3cadcc64(data: typing.BinaryIO, property_size: int):
return UnknownStruct54.from_stream(data, property_size)
def _decode_number_of_choices(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct53_0x5e856665(data: typing.BinaryIO, property_size: int):
return UnknownStruct53.from_stream(data, property_size)
def _decode_unknown_struct53_0xed114ba6(data: typing.BinaryIO, property_size: int):
return UnknownStruct53.from_stream(data, property_size)
def _decode_unknown_struct53_0x839d50e7(data: typing.BinaryIO, property_size: int):
return UnknownStruct53.from_stream(data, property_size)
def _decode_unknown_struct53_0x51481661(data: typing.BinaryIO, property_size: int):
return UnknownStruct53.from_stream(data, property_size)
def _decode_unknown_struct53_0x3fc40d20(data: typing.BinaryIO, property_size: int):
return UnknownStruct53.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x98cbfedc: ('frequency', _decode_frequency),
0x8772cb7e: ('unknown_struct54_0x8772cb7e', _decode_unknown_struct54_0x8772cb7e),
0x3cadcc64: ('unknown_struct54_0x3cadcc64', _decode_unknown_struct54_0x3cadcc64),
0x9156ba5f: ('number_of_choices', _decode_number_of_choices),
0x5e856665: ('unknown_struct53_0x5e856665', _decode_unknown_struct53_0x5e856665),
0xed114ba6: ('unknown_struct53_0xed114ba6', _decode_unknown_struct53_0xed114ba6),
0x839d50e7: ('unknown_struct53_0x839d50e7', _decode_unknown_struct53_0x839d50e7),
0x51481661: ('unknown_struct53_0x51481661', _decode_unknown_struct53_0x51481661),
0x3fc40d20: ('unknown_struct53_0x3fc40d20', _decode_unknown_struct53_0x3fc40d20),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct55.py | 0.592902 | 0.280686 | UnknownStruct55.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 UnknownStruct176(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
start1_player: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
start2_player: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
extras: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
options: 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)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
player1_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
player2_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
extras_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
options_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_struct28: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
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\x10') # 16 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'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'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'1D\x97\x04') # 0x31449704
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.start1_player))
data.write(b'F\xdaE\xf4') # 0x46da45f4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.start2_player))
data.write(b'\xf19\xaf\x99') # 0xf139af99
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.extras))
data.write(b'\xac\xe4\x06~') # 0xace4067e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.options))
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'C\x05OG') # 0x43054f47
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'\xd6\xf9\xa7\x0f') # 0xd6f9a70f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.player1_sound))
data.write(b'O\x1b\xc1\x0e') # 0x4f1bc10e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.player2_sound))
data.write(b'\xca\xc2S\x16') # 0xcac25316
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.extras_sound))
data.write(b'\xea\x11\x9b,') # 0xea119b2c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.options_sound))
data.write(b'\x8c\x9cWL') # 0x8c9c574c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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(
gui_frame=data['gui_frame'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
title=data['title'],
start1_player=data['start1_player'],
start2_player=data['start2_player'],
extras=data['extras'],
options=data['options'],
back=data['back'],
back_core=data['back_core'],
strg=data['strg'],
player1_sound=data['player1_sound'],
player2_sound=data['player2_sound'],
extras_sound=data['extras_sound'],
options_sound=data['options_sound'],
unknown_struct28=UnknownStruct28.from_json(data['unknown_struct28']),
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'title': self.title,
'start1_player': self.start1_player,
'start2_player': self.start2_player,
'extras': self.extras,
'options': self.options,
'back': self.back,
'back_core': self.back_core,
'strg': self.strg,
'player1_sound': self.player1_sound,
'player2_sound': self.player2_sound,
'extras_sound': self.extras_sound,
'options_sound': self.options_sound,
'unknown_struct28': self.unknown_struct28.to_json(),
'text_background': self.text_background,
}
def _decode_gui_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_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_start1_player(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_start2_player(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_extras(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_options(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_strg(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_player1_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_player2_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_extras_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_options_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct28(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
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]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xa4f20c17: ('title', _decode_title),
0x31449704: ('start1_player', _decode_start1_player),
0x46da45f4: ('start2_player', _decode_start2_player),
0xf139af99: ('extras', _decode_extras),
0xace4067e: ('options', _decode_options),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x43054f47: ('strg', _decode_strg),
0xd6f9a70f: ('player1_sound', _decode_player1_sound),
0x4f1bc10e: ('player2_sound', _decode_player2_sound),
0xcac25316: ('extras_sound', _decode_extras_sound),
0xea119b2c: ('options_sound', _decode_options_sound),
0x8c9c574c: ('unknown_struct28', _decode_unknown_struct28),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct176.py | 0.481941 | 0.162413 | UnknownStruct176.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 UnknownStruct29(BaseProperty):
hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, 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\x01') # 1 properties
data.write(b'\xf2)\x9e\xd6') # 0xf2299ed6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_frame))
@classmethod
def from_json(cls, data: dict):
return cls(
hud_frame=data['hud_frame'],
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf2299ed6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct29]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(14))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct29(
dec[2],
)
def _decode_hud_frame(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),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct29.py | 0.609408 | 0.259415 | UnknownStruct29.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 AreaDamageData(BaseProperty):
attack_range_max: float = dataclasses.field(default=0.0)
attack_range_min: float = dataclasses.field(default=0.0)
initial_attack_delay: float = dataclasses.field(default=0.0)
attack_interval_max: float = dataclasses.field(default=3.0)
attack_interval_min: float = dataclasses.field(default=3.0)
effect_duration_max: float = dataclasses.field(default=3.0)
effect_duration_min: float = dataclasses.field(default=3.0)
extra_damage_duration: float = dataclasses.field(default=0.0)
can_activate_while_stunned: bool = dataclasses.field(default=False)
unknown: bool = dataclasses.field(default=True)
collision_actor: int = dataclasses.field(default=1)
mode: int = dataclasses.field(default=188856672) # Choice
@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'\xe7\r\x05\x92') # 0xe70d0592
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_range_max))
data.write(b'\x01m\xaas') # 0x16daa73
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_range_min))
data.write(b'\x91\x9a\x9e\xe2') # 0x919a9ee2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_attack_delay))
data.write(b'\xd7\x8bW\x88') # 0xd78b5788
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_interval_max))
data.write(b'1\xeb\xf8i') # 0x31ebf869
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_interval_min))
data.write(b'\x7f\x12z\xea') # 0x7f127aea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.effect_duration_max))
data.write(b'\x99r\xd5\x0b') # 0x9972d50b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.effect_duration_min))
data.write(b'U\xd8\xbb\xf8') # 0x55d8bbf8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.extra_damage_duration))
data.write(b'Z\x8a\xe7J') # 0x5a8ae74a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_activate_while_stunned))
data.write(b'kn\xcc]') # 0x6b6ecc5d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x95|V\xbc') # 0x957c56bc
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.collision_actor))
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mode))
@classmethod
def from_json(cls, data: dict):
return cls(
attack_range_max=data['attack_range_max'],
attack_range_min=data['attack_range_min'],
initial_attack_delay=data['initial_attack_delay'],
attack_interval_max=data['attack_interval_max'],
attack_interval_min=data['attack_interval_min'],
effect_duration_max=data['effect_duration_max'],
effect_duration_min=data['effect_duration_min'],
extra_damage_duration=data['extra_damage_duration'],
can_activate_while_stunned=data['can_activate_while_stunned'],
unknown=data['unknown'],
collision_actor=data['collision_actor'],
mode=data['mode'],
)
def to_json(self) -> dict:
return {
'attack_range_max': self.attack_range_max,
'attack_range_min': self.attack_range_min,
'initial_attack_delay': self.initial_attack_delay,
'attack_interval_max': self.attack_interval_max,
'attack_interval_min': self.attack_interval_min,
'effect_duration_max': self.effect_duration_max,
'effect_duration_min': self.effect_duration_min,
'extra_damage_duration': self.extra_damage_duration,
'can_activate_while_stunned': self.can_activate_while_stunned,
'unknown': self.unknown,
'collision_actor': self.collision_actor,
'mode': self.mode,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe70d0592, 0x16daa73, 0x919a9ee2, 0xd78b5788, 0x31ebf869, 0x7f127aea, 0x9972d50b, 0x55d8bbf8, 0x5a8ae74a, 0x6b6ecc5d, 0x957c56bc, 0xb8f60f9a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AreaDamageData]:
if property_count != 12:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLH?LH?LHlLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(114))
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 AreaDamageData(
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_attack_range_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_range_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_attack_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_interval_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_interval_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_effect_duration_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_effect_duration_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_extra_damage_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_can_activate_while_stunned(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_collision_actor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mode(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]]] = {
0xe70d0592: ('attack_range_max', _decode_attack_range_max),
0x16daa73: ('attack_range_min', _decode_attack_range_min),
0x919a9ee2: ('initial_attack_delay', _decode_initial_attack_delay),
0xd78b5788: ('attack_interval_max', _decode_attack_interval_max),
0x31ebf869: ('attack_interval_min', _decode_attack_interval_min),
0x7f127aea: ('effect_duration_max', _decode_effect_duration_max),
0x9972d50b: ('effect_duration_min', _decode_effect_duration_min),
0x55d8bbf8: ('extra_damage_duration', _decode_extra_damage_duration),
0x5a8ae74a: ('can_activate_while_stunned', _decode_can_activate_while_stunned),
0x6b6ecc5d: ('unknown', _decode_unknown),
0x957c56bc: ('collision_actor', _decode_collision_actor),
0xb8f60f9a: ('mode', _decode_mode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/AreaDamageData.py | 0.642993 | 0.267764 | AreaDamageData.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 AreaAttackBehaviorData(BaseProperty):
attack_range_max: float = dataclasses.field(default=0.0)
attack_range_min: float = dataclasses.field(default=0.0)
initial_attack_delay: float = dataclasses.field(default=0.0)
attack_interval_max: float = dataclasses.field(default=3.0)
attack_interval_min: float = dataclasses.field(default=3.0)
mode: int = dataclasses.field(default=1686810489) # Choice
@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'\xe7\r\x05\x92') # 0xe70d0592
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_range_max))
data.write(b'\x01m\xaas') # 0x16daa73
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_range_min))
data.write(b'\x91\x9a\x9e\xe2') # 0x919a9ee2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_attack_delay))
data.write(b'\xd7\x8bW\x88') # 0xd78b5788
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_interval_max))
data.write(b'1\xeb\xf8i') # 0x31ebf869
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_interval_min))
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mode))
@classmethod
def from_json(cls, data: dict):
return cls(
attack_range_max=data['attack_range_max'],
attack_range_min=data['attack_range_min'],
initial_attack_delay=data['initial_attack_delay'],
attack_interval_max=data['attack_interval_max'],
attack_interval_min=data['attack_interval_min'],
mode=data['mode'],
)
def to_json(self) -> dict:
return {
'attack_range_max': self.attack_range_max,
'attack_range_min': self.attack_range_min,
'initial_attack_delay': self.initial_attack_delay,
'attack_interval_max': self.attack_interval_max,
'attack_interval_min': self.attack_interval_min,
'mode': self.mode,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe70d0592, 0x16daa73, 0x919a9ee2, 0xd78b5788, 0x31ebf869, 0xb8f60f9a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AreaAttackBehaviorData]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHL')
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 AreaAttackBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_attack_range_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_range_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_attack_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_interval_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_interval_min(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe70d0592: ('attack_range_max', _decode_attack_range_max),
0x16daa73: ('attack_range_min', _decode_attack_range_min),
0x919a9ee2: ('initial_attack_delay', _decode_initial_attack_delay),
0xd78b5788: ('attack_interval_max', _decode_attack_interval_max),
0x31ebf869: ('attack_interval_min', _decode_attack_interval_min),
0xb8f60f9a: ('mode', _decode_mode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/AreaAttackBehaviorData.py | 0.643777 | 0.282003 | AreaAttackBehaviorData.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 VolcanoBossBodyPartStructA(BaseProperty):
attack_type: enums.AttackType = dataclasses.field(default=enums.AttackType.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'\x07\xd99\xa1') # 0x7d939a1
data.write(b'\x00\x04') # size
self.attack_type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
attack_type=enums.AttackType.from_json(data['attack_type']),
)
def to_json(self) -> dict:
return {
'attack_type': self.attack_type.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x7d939a1)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VolcanoBossBodyPartStructA]:
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 VolcanoBossBodyPartStructA(
enums.AttackType(dec[2]),
)
def _decode_attack_type(data: typing.BinaryIO, property_size: int):
return enums.AttackType.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7d939a1: ('attack_type', _decode_attack_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VolcanoBossBodyPartStructA.py | 0.607663 | 0.321567 | VolcanoBossBodyPartStructA.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 UnknownStruct151(BaseProperty):
hud_frame: 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_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\x04') # 4 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'\xe6\xf6\xe2p') # 0xe6f6e270
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.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'],
text_string=data['text_string'],
confirm_string=data['confirm_string'],
cancel_string=data['cancel_string'],
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
'text_string': self.text_string,
'confirm_string': self.confirm_string,
'cancel_string': self.cancel_string,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf2299ed6, 0xe6f6e270, 0x4fabac09, 0xcb6af89b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct151]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(56))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct151(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_hud_frame(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_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),
0xe6f6e270: ('text_string', _decode_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/UnknownStruct151.py | 0.585101 | 0.247226 | UnknownStruct151.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 UnknownStruct138(BaseProperty):
unknown_0xd4b4ad93: float = dataclasses.field(default=-1.0)
unknown_0x035f1fd2: float = dataclasses.field(default=1.0)
unknown_0x354d1781: float = dataclasses.field(default=-1.0)
unknown_0xe2a6a5c0: 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'\xd4\xb4\xad\x93') # 0xd4b4ad93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd4b4ad93))
data.write(b'\x03_\x1f\xd2') # 0x35f1fd2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x035f1fd2))
data.write(b'5M\x17\x81') # 0x354d1781
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x354d1781))
data.write(b'\xe2\xa6\xa5\xc0') # 0xe2a6a5c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe2a6a5c0))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xd4b4ad93=data['unknown_0xd4b4ad93'],
unknown_0x035f1fd2=data['unknown_0x035f1fd2'],
unknown_0x354d1781=data['unknown_0x354d1781'],
unknown_0xe2a6a5c0=data['unknown_0xe2a6a5c0'],
)
def to_json(self) -> dict:
return {
'unknown_0xd4b4ad93': self.unknown_0xd4b4ad93,
'unknown_0x035f1fd2': self.unknown_0x035f1fd2,
'unknown_0x354d1781': self.unknown_0x354d1781,
'unknown_0xe2a6a5c0': self.unknown_0xe2a6a5c0,
}
_FAST_FORMAT = None
_FAST_IDS = (0xd4b4ad93, 0x35f1fd2, 0x354d1781, 0xe2a6a5c0)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct138]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
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 UnknownStruct138(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_unknown_0xd4b4ad93(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x035f1fd2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x354d1781(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe2a6a5c0(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]]] = {
0xd4b4ad93: ('unknown_0xd4b4ad93', _decode_unknown_0xd4b4ad93),
0x35f1fd2: ('unknown_0x035f1fd2', _decode_unknown_0x035f1fd2),
0x354d1781: ('unknown_0x354d1781', _decode_unknown_0x354d1781),
0xe2a6a5c0: ('unknown_0xe2a6a5c0', _decode_unknown_0xe2a6a5c0),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct138.py | 0.602296 | 0.279634 | UnknownStruct138.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
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class PlatformMotionProperties(BaseProperty):
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)
speed_multiplier: float = dataclasses.field(default=1.0)
initial_time: float = dataclasses.field(default=0.0)
unknown: int = dataclasses.field(default=262432)
roll_control_spline: Spline = dataclasses.field(default_factory=Spline)
yaw_control_spline: Spline = dataclasses.field(default_factory=Spline)
pitch_control_spline: Spline = dataclasses.field(default_factory=Spline)
target_object_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\n') # 10 properties
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))
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'\xa5u=R') # 0xa5753d52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_time))
data.write(b'\xae\x80b\x8f') # 0xae80628f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'b\x8b\xdf\x0f') # 0x628bdf0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.roll_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'x\xd0:2') # 0x78d03a32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.yaw_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'\xb4\xa2\xe1Z') # 0xb4a2e15a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pitch_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'\xb5\xbf\xab\x00') # 0xb5bfab00
data.write(b'\x00\x0c') # size
self.target_object_offset.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
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'],
speed_multiplier=data['speed_multiplier'],
initial_time=data['initial_time'],
unknown=data['unknown'],
roll_control_spline=Spline.from_json(data['roll_control_spline']),
yaw_control_spline=Spline.from_json(data['yaw_control_spline']),
pitch_control_spline=Spline.from_json(data['pitch_control_spline']),
target_object_offset=Vector.from_json(data['target_object_offset']),
)
def to_json(self) -> dict:
return {
'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,
'speed_multiplier': self.speed_multiplier,
'initial_time': self.initial_time,
'unknown': self.unknown,
'roll_control_spline': self.roll_control_spline.to_json(),
'yaw_control_spline': self.yaw_control_spline.to_json(),
'pitch_control_spline': self.pitch_control_spline.to_json(),
'target_object_offset': self.target_object_offset.to_json(),
}
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]
def _decode_speed_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_time(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('>l', data.read(4))[0]
def _decode_roll_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_yaw_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pitch_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_target_object_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]]] = {
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
0x4885dffa: ('speed_multiplier', _decode_speed_multiplier),
0xa5753d52: ('initial_time', _decode_initial_time),
0xae80628f: ('unknown', _decode_unknown),
0x628bdf0f: ('roll_control_spline', _decode_roll_control_spline),
0x78d03a32: ('yaw_control_spline', _decode_yaw_control_spline),
0xb4a2e15a: ('pitch_control_spline', _decode_pitch_control_spline),
0xb5bfab00: ('target_object_offset', _decode_target_object_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlatformMotionProperties.py | 0.603932 | 0.285646 | PlatformMotionProperties.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 BarrelCannonData(BaseProperty):
grab_radius: float = dataclasses.field(default=1.5)
release_radius: float = dataclasses.field(default=3.0)
ignore_gravity_radius: float = dataclasses.field(default=1.0)
unknown_0x49d8e65a: bool = dataclasses.field(default=False)
launch_behavior: int = dataclasses.field(default=0) # Choice
launch_timer: float = dataclasses.field(default=0.15000000596046448)
launch_direction: int = dataclasses.field(default=0) # Choice
launch_speed: float = dataclasses.field(default=21.0)
unknown_0xc440842b: float = dataclasses.field(default=0.0)
unknown_0x9bb1543f: float = dataclasses.field(default=1.0499999523162842)
target_reorientation_time: float = dataclasses.field(default=0.20000000298023224)
render_texture_set: int = dataclasses.field(default=0)
unknown_0x97ad5bee: bool = dataclasses.field(default=True)
unknown_0x094b5ad6: bool = dataclasses.field(default=True)
unknown_0x25967162: bool = dataclasses.field(default=True)
unknown_0x26b5fcdf: bool = dataclasses.field(default=True)
allow_air_control: bool = dataclasses.field(default=False)
unknown_0x36051905: bool = dataclasses.field(default=True)
unknown_0xfc4118dd: bool = dataclasses.field(default=True)
unknown_0x06d1b8c7: bool = dataclasses.field(default=False)
unknown_0x341f63f8: bool = dataclasses.field(default=False)
unknown_0x4d6847e5: bool = dataclasses.field(default=False)
unknown_0x2255a13d: bool = dataclasses.field(default=False)
barrel_cannon_enum_0x98501823: enums.BarrelCannonEnum = dataclasses.field(default=enums.BarrelCannonEnum.Unknown2)
barrel_cannon_enum_0x098ecab6: enums.BarrelCannonEnum = dataclasses.field(default=enums.BarrelCannonEnum.Unknown4)
@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\x19') # 25 properties
data.write(b'\x89fG#') # 0x89664723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grab_radius))
data.write(b'+/E\x19') # 0x2b2f4519
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.release_radius))
data.write(b'\xfb5\xa9Z') # 0xfb35a95a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ignore_gravity_radius))
data.write(b'I\xd8\xe6Z') # 0x49d8e65a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x49d8e65a))
data.write(b'-*J\xd6') # 0x2d2a4ad6
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.launch_behavior))
data.write(b'\xd5\xed\x0fw') # 0xd5ed0f77
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.launch_timer))
data.write(b'\x89\xd7y\x1e') # 0x89d7791e
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.launch_direction))
data.write(b'18\x1a\x17') # 0x31381a17
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.launch_speed))
data.write(b'\xc4@\x84+') # 0xc440842b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc440842b))
data.write(b'\x9b\xb1T?') # 0x9bb1543f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9bb1543f))
data.write(b'\x06\x13!\xae') # 0x61321ae
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_reorientation_time))
data.write(b'2\xfa\xb9~') # 0x32fab97e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_texture_set))
data.write(b'\x97\xad[\xee') # 0x97ad5bee
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x97ad5bee))
data.write(b'\tKZ\xd6') # 0x94b5ad6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x094b5ad6))
data.write(b'%\x96qb') # 0x25967162
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x25967162))
data.write(b'&\xb5\xfc\xdf') # 0x26b5fcdf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x26b5fcdf))
data.write(b'l*\xd8\xb4') # 0x6c2ad8b4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_air_control))
data.write(b'6\x05\x19\x05') # 0x36051905
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x36051905))
data.write(b'\xfcA\x18\xdd') # 0xfc4118dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xfc4118dd))
data.write(b'\x06\xd1\xb8\xc7') # 0x6d1b8c7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x06d1b8c7))
data.write(b'4\x1fc\xf8') # 0x341f63f8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x341f63f8))
data.write(b'MhG\xe5') # 0x4d6847e5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4d6847e5))
data.write(b'"U\xa1=') # 0x2255a13d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2255a13d))
data.write(b'\x98P\x18#') # 0x98501823
data.write(b'\x00\x04') # size
self.barrel_cannon_enum_0x98501823.to_stream(data)
data.write(b'\t\x8e\xca\xb6') # 0x98ecab6
data.write(b'\x00\x04') # size
self.barrel_cannon_enum_0x098ecab6.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
grab_radius=data['grab_radius'],
release_radius=data['release_radius'],
ignore_gravity_radius=data['ignore_gravity_radius'],
unknown_0x49d8e65a=data['unknown_0x49d8e65a'],
launch_behavior=data['launch_behavior'],
launch_timer=data['launch_timer'],
launch_direction=data['launch_direction'],
launch_speed=data['launch_speed'],
unknown_0xc440842b=data['unknown_0xc440842b'],
unknown_0x9bb1543f=data['unknown_0x9bb1543f'],
target_reorientation_time=data['target_reorientation_time'],
render_texture_set=data['render_texture_set'],
unknown_0x97ad5bee=data['unknown_0x97ad5bee'],
unknown_0x094b5ad6=data['unknown_0x094b5ad6'],
unknown_0x25967162=data['unknown_0x25967162'],
unknown_0x26b5fcdf=data['unknown_0x26b5fcdf'],
allow_air_control=data['allow_air_control'],
unknown_0x36051905=data['unknown_0x36051905'],
unknown_0xfc4118dd=data['unknown_0xfc4118dd'],
unknown_0x06d1b8c7=data['unknown_0x06d1b8c7'],
unknown_0x341f63f8=data['unknown_0x341f63f8'],
unknown_0x4d6847e5=data['unknown_0x4d6847e5'],
unknown_0x2255a13d=data['unknown_0x2255a13d'],
barrel_cannon_enum_0x98501823=enums.BarrelCannonEnum.from_json(data['barrel_cannon_enum_0x98501823']),
barrel_cannon_enum_0x098ecab6=enums.BarrelCannonEnum.from_json(data['barrel_cannon_enum_0x098ecab6']),
)
def to_json(self) -> dict:
return {
'grab_radius': self.grab_radius,
'release_radius': self.release_radius,
'ignore_gravity_radius': self.ignore_gravity_radius,
'unknown_0x49d8e65a': self.unknown_0x49d8e65a,
'launch_behavior': self.launch_behavior,
'launch_timer': self.launch_timer,
'launch_direction': self.launch_direction,
'launch_speed': self.launch_speed,
'unknown_0xc440842b': self.unknown_0xc440842b,
'unknown_0x9bb1543f': self.unknown_0x9bb1543f,
'target_reorientation_time': self.target_reorientation_time,
'render_texture_set': self.render_texture_set,
'unknown_0x97ad5bee': self.unknown_0x97ad5bee,
'unknown_0x094b5ad6': self.unknown_0x094b5ad6,
'unknown_0x25967162': self.unknown_0x25967162,
'unknown_0x26b5fcdf': self.unknown_0x26b5fcdf,
'allow_air_control': self.allow_air_control,
'unknown_0x36051905': self.unknown_0x36051905,
'unknown_0xfc4118dd': self.unknown_0xfc4118dd,
'unknown_0x06d1b8c7': self.unknown_0x06d1b8c7,
'unknown_0x341f63f8': self.unknown_0x341f63f8,
'unknown_0x4d6847e5': self.unknown_0x4d6847e5,
'unknown_0x2255a13d': self.unknown_0x2255a13d,
'barrel_cannon_enum_0x98501823': self.barrel_cannon_enum_0x98501823.to_json(),
'barrel_cannon_enum_0x098ecab6': self.barrel_cannon_enum_0x098ecab6.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x89664723, 0x2b2f4519, 0xfb35a95a, 0x49d8e65a, 0x2d2a4ad6, 0xd5ed0f77, 0x89d7791e, 0x31381a17, 0xc440842b, 0x9bb1543f, 0x61321ae, 0x32fab97e, 0x97ad5bee, 0x94b5ad6, 0x25967162, 0x26b5fcdf, 0x6c2ad8b4, 0x36051905, 0xfc4118dd, 0x6d1b8c7, 0x341f63f8, 0x4d6847e5, 0x2255a13d, 0x98501823, 0x98ecab6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BarrelCannonData]:
if property_count != 25:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLH?LHLLHfLHLLHfLHfLHfLHfLHlLH?LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?LHLLHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(214))
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], dec[54], dec[57], dec[60], dec[63], dec[66], dec[69], dec[72]) != _FAST_IDS:
data.seek(before)
return None
return BarrelCannonData(
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],
dec[47],
dec[50],
dec[53],
dec[56],
dec[59],
dec[62],
dec[65],
dec[68],
enums.BarrelCannonEnum(dec[71]),
enums.BarrelCannonEnum(dec[74]),
)
def _decode_grab_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_release_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ignore_gravity_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x49d8e65a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_launch_behavior(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_launch_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_launch_direction(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_launch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc440842b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9bb1543f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_reorientation_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_render_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x97ad5bee(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x094b5ad6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x25967162(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x26b5fcdf(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_air_control(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x36051905(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xfc4118dd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x06d1b8c7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x341f63f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4d6847e5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2255a13d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_barrel_cannon_enum_0x98501823(data: typing.BinaryIO, property_size: int):
return enums.BarrelCannonEnum.from_stream(data)
def _decode_barrel_cannon_enum_0x098ecab6(data: typing.BinaryIO, property_size: int):
return enums.BarrelCannonEnum.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x89664723: ('grab_radius', _decode_grab_radius),
0x2b2f4519: ('release_radius', _decode_release_radius),
0xfb35a95a: ('ignore_gravity_radius', _decode_ignore_gravity_radius),
0x49d8e65a: ('unknown_0x49d8e65a', _decode_unknown_0x49d8e65a),
0x2d2a4ad6: ('launch_behavior', _decode_launch_behavior),
0xd5ed0f77: ('launch_timer', _decode_launch_timer),
0x89d7791e: ('launch_direction', _decode_launch_direction),
0x31381a17: ('launch_speed', _decode_launch_speed),
0xc440842b: ('unknown_0xc440842b', _decode_unknown_0xc440842b),
0x9bb1543f: ('unknown_0x9bb1543f', _decode_unknown_0x9bb1543f),
0x61321ae: ('target_reorientation_time', _decode_target_reorientation_time),
0x32fab97e: ('render_texture_set', _decode_render_texture_set),
0x97ad5bee: ('unknown_0x97ad5bee', _decode_unknown_0x97ad5bee),
0x94b5ad6: ('unknown_0x094b5ad6', _decode_unknown_0x094b5ad6),
0x25967162: ('unknown_0x25967162', _decode_unknown_0x25967162),
0x26b5fcdf: ('unknown_0x26b5fcdf', _decode_unknown_0x26b5fcdf),
0x6c2ad8b4: ('allow_air_control', _decode_allow_air_control),
0x36051905: ('unknown_0x36051905', _decode_unknown_0x36051905),
0xfc4118dd: ('unknown_0xfc4118dd', _decode_unknown_0xfc4118dd),
0x6d1b8c7: ('unknown_0x06d1b8c7', _decode_unknown_0x06d1b8c7),
0x341f63f8: ('unknown_0x341f63f8', _decode_unknown_0x341f63f8),
0x4d6847e5: ('unknown_0x4d6847e5', _decode_unknown_0x4d6847e5),
0x2255a13d: ('unknown_0x2255a13d', _decode_unknown_0x2255a13d),
0x98501823: ('barrel_cannon_enum_0x98501823', _decode_barrel_cannon_enum_0x98501823),
0x98ecab6: ('barrel_cannon_enum_0x098ecab6', _decode_barrel_cannon_enum_0x098ecab6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BarrelCannonData.py | 0.609989 | 0.272496 | BarrelCannonData.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
@dataclasses.dataclass()
class UnknownStruct260(BaseProperty):
unknown_0x348c9d90: float = dataclasses.field(default=20.0)
flight_sound_deceleration_k: float = dataclasses.field(default=1.0)
flight_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
flight_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
flight_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
flight_sound_volume: Spline = dataclasses.field(default_factory=Spline)
caud_0xb0c2f5f6: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xbd894993: Spline = dataclasses.field(default_factory=Spline)
flight_sound2_pitch: Spline = dataclasses.field(default_factory=Spline)
flight_sound2_volume: Spline = dataclasses.field(default_factory=Spline)
hit_player_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0xc8b23273: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
swoop_interrupted_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\r') # 13 properties
data.write(b'4\x8c\x9d\x90') # 0x348c9d90
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x348c9d90))
data.write(b'z}\xf6\xe3') # 0x7a7df6e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flight_sound_deceleration_k))
data.write(b'\xe1\xe6k$') # 0xe1e66b24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flight_sound))
data.write(b'\xb4\x13\xc4_') # 0xb413c45f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_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'v\xc7FL') # 0x76c7464c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_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'\x10\xe0Z\xaf') # 0x10e05aaf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xc2\xf5\xf6') # 0xb0c2f5f6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xb0c2f5f6))
data.write(b'\xbd\x89I\x93') # 0xbd894993
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xbd894993.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05)\x1e\xf7') # 0x5291ef7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound2_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'L \xde\xf3') # 0x4c20def3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound2_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%\x9c\t9') # 0x259c0939
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hit_player_sound))
data.write(b'\xc8\xb22s') # 0xc8b23273
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xc8b23273))
data.write(b'\xbe_\x11\x8d') # 0xbe5f118d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.swoop_interrupted_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x348c9d90=data['unknown_0x348c9d90'],
flight_sound_deceleration_k=data['flight_sound_deceleration_k'],
flight_sound=data['flight_sound'],
flight_sound_low_pass_filter=Spline.from_json(data['flight_sound_low_pass_filter']),
flight_sound_pitch=Spline.from_json(data['flight_sound_pitch']),
flight_sound_volume=Spline.from_json(data['flight_sound_volume']),
caud_0xb0c2f5f6=data['caud_0xb0c2f5f6'],
unknown_0xbd894993=Spline.from_json(data['unknown_0xbd894993']),
flight_sound2_pitch=Spline.from_json(data['flight_sound2_pitch']),
flight_sound2_volume=Spline.from_json(data['flight_sound2_volume']),
hit_player_sound=data['hit_player_sound'],
caud_0xc8b23273=data['caud_0xc8b23273'],
swoop_interrupted_sound=data['swoop_interrupted_sound'],
)
def to_json(self) -> dict:
return {
'unknown_0x348c9d90': self.unknown_0x348c9d90,
'flight_sound_deceleration_k': self.flight_sound_deceleration_k,
'flight_sound': self.flight_sound,
'flight_sound_low_pass_filter': self.flight_sound_low_pass_filter.to_json(),
'flight_sound_pitch': self.flight_sound_pitch.to_json(),
'flight_sound_volume': self.flight_sound_volume.to_json(),
'caud_0xb0c2f5f6': self.caud_0xb0c2f5f6,
'unknown_0xbd894993': self.unknown_0xbd894993.to_json(),
'flight_sound2_pitch': self.flight_sound2_pitch.to_json(),
'flight_sound2_volume': self.flight_sound2_volume.to_json(),
'hit_player_sound': self.hit_player_sound,
'caud_0xc8b23273': self.caud_0xc8b23273,
'swoop_interrupted_sound': self.swoop_interrupted_sound,
}
def _decode_unknown_0x348c9d90(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_sound_deceleration_k(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flight_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_caud_0xb0c2f5f6(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xbd894993(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound2_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound2_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_hit_player_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0xc8b23273(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_swoop_interrupted_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]]] = {
0x348c9d90: ('unknown_0x348c9d90', _decode_unknown_0x348c9d90),
0x7a7df6e3: ('flight_sound_deceleration_k', _decode_flight_sound_deceleration_k),
0xe1e66b24: ('flight_sound', _decode_flight_sound),
0xb413c45f: ('flight_sound_low_pass_filter', _decode_flight_sound_low_pass_filter),
0x76c7464c: ('flight_sound_pitch', _decode_flight_sound_pitch),
0x10e05aaf: ('flight_sound_volume', _decode_flight_sound_volume),
0xb0c2f5f6: ('caud_0xb0c2f5f6', _decode_caud_0xb0c2f5f6),
0xbd894993: ('unknown_0xbd894993', _decode_unknown_0xbd894993),
0x5291ef7: ('flight_sound2_pitch', _decode_flight_sound2_pitch),
0x4c20def3: ('flight_sound2_volume', _decode_flight_sound2_volume),
0x259c0939: ('hit_player_sound', _decode_hit_player_sound),
0xc8b23273: ('caud_0xc8b23273', _decode_caud_0xc8b23273),
0xbe5f118d: ('swoop_interrupted_sound', _decode_swoop_interrupted_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct260.py | 0.568895 | 0.227974 | UnknownStruct260.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 UnknownStruct201(BaseProperty):
unknown: int = dataclasses.field(default=1694551927) # Choice
turn_rate: float = dataclasses.field(default=90.0)
velocity: 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'|q\xcb\xad') # 0x7c71cbad
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown))
data.write(b'\xe3M\xc7\x03') # 0xe34dc703
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_rate))
data.write(b'\x13\xebZ}') # 0x13eb5a7d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.velocity.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=data['unknown'],
turn_rate=data['turn_rate'],
velocity=Spline.from_json(data['velocity']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'turn_rate': self.turn_rate,
'velocity': self.velocity.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_turn_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_velocity(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]]] = {
0x7c71cbad: ('unknown', _decode_unknown),
0xe34dc703: ('turn_rate', _decode_turn_rate),
0x13eb5a7d: ('velocity', _decode_velocity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct201.py | 0.654784 | 0.304746 | UnknownStruct201.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 UnknownStruct141(BaseProperty):
unknown_0x42b84bb2: int = dataclasses.field(default=2893014572) # Choice
unknown_0x6cd8813e: float = dataclasses.field(default=0.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]
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'B\xb8K\xb2') # 0x42b84bb2
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x42b84bb2))
data.write(b'l\xd8\x81>') # 0x6cd8813e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6cd8813e))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x42b84bb2=data['unknown_0x42b84bb2'],
unknown_0x6cd8813e=data['unknown_0x6cd8813e'],
)
def to_json(self) -> dict:
return {
'unknown_0x42b84bb2': self.unknown_0x42b84bb2,
'unknown_0x6cd8813e': self.unknown_0x6cd8813e,
}
_FAST_FORMAT = None
_FAST_IDS = (0x42b84bb2, 0x6cd8813e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct141]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct141(
dec[2],
dec[5],
)
def _decode_unknown_0x42b84bb2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x6cd8813e(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]]] = {
0x42b84bb2: ('unknown_0x42b84bb2', _decode_unknown_0x42b84bb2),
0x6cd8813e: ('unknown_0x6cd8813e', _decode_unknown_0x6cd8813e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct141.py | 0.620392 | 0.335473 | UnknownStruct141.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 ActorMultiKeyframeStruct(BaseProperty):
unknown: int = dataclasses.field(default=0)
loop: bool = dataclasses.field(default=False)
force_secondary: 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'\xc2\x15\xa2O') # 0xc215a24f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\\\xce[\x97') # 0x5cce5b97
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_secondary))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
loop=data['loop'],
force_secondary=data['force_secondary'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'loop': self.loop,
'force_secondary': self.force_secondary,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc215a24f, 0xeda47ff6, 0x5cce5b97)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ActorMultiKeyframeStruct]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(24))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return ActorMultiKeyframeStruct(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown(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]
def _decode_force_secondary(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]]] = {
0xc215a24f: ('unknown', _decode_unknown),
0xeda47ff6: ('loop', _decode_loop),
0x5cce5b97: ('force_secondary', _decode_force_secondary),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ActorMultiKeyframeStruct.py | 0.601828 | 0.304003 | ActorMultiKeyframeStruct.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 UnknownStruct277(BaseProperty):
location: enums.Location = dataclasses.field(default=enums.Location.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'\xc5\xc9\x189') # 0xc5c91839
data.write(b'\x00\x04') # size
self.location.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
location=enums.Location.from_json(data['location']),
)
def to_json(self) -> dict:
return {
'location': self.location.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0xc5c91839)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct277]:
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 UnknownStruct277(
enums.Location(dec[2]),
)
def _decode_location(data: typing.BinaryIO, property_size: int):
return enums.Location.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc5c91839: ('location', _decode_location),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct277.py | 0.642881 | 0.279204 | UnknownStruct277.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 PathDeterminationMethodType(BaseProperty):
path_determination_method: enums.PathDeterminationMethod = dataclasses.field(default=enums.PathDeterminationMethod.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'\xb8\r\x00\xa8') # 0xb80d00a8
data.write(b'\x00\x04') # size
self.path_determination_method.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
path_determination_method=enums.PathDeterminationMethod.from_json(data['path_determination_method']),
)
def to_json(self) -> dict:
return {
'path_determination_method': self.path_determination_method.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0xb80d00a8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PathDeterminationMethodType]:
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 PathDeterminationMethodType(
enums.PathDeterminationMethod(dec[2]),
)
def _decode_path_determination_method(data: typing.BinaryIO, property_size: int):
return enums.PathDeterminationMethod.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb80d00a8: ('path_determination_method', _decode_path_determination_method),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PathDeterminationMethodType.py | 0.658418 | 0.290062 | PathDeterminationMethodType.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
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 BalloonData(BaseProperty):
balloon_character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
texture_set: int = dataclasses.field(default=0)
mass: float = dataclasses.field(default=10.0)
downward_velocity: float = dataclasses.field(default=3.0)
extra_downward_collision: float = dataclasses.field(default=3.0)
dk_riding_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=-4.0))
start_offset: float = dataclasses.field(default=15.0)
drop_height_above_spawn_point: float = dataclasses.field(default=1.0)
dk_pop_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
d_kand_diddy_pop_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
dk_pop_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
d_kand_diddy_pop_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
balloonless_mode_drop_timer: 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]
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'\xf8\xb3\xab\xe0') # 0xf8b3abe0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balloon_character.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k@\xac\xef') # 0x6b40acef
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.texture_set))
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'\xdd\xb1iy') # 0xddb16979
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.downward_velocity))
data.write(b"\x9a'\xdd\xc3") # 0x9a27ddc3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.extra_downward_collision))
data.write(b'\xc0\xfe\x10\xc6') # 0xc0fe10c6
data.write(b'\x00\x0c') # size
self.dk_riding_offset.to_stream(data)
data.write(b'@\x96\x18\xb6') # 0x409618b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_offset))
data.write(b'\x80ax\xb3') # 0x806178b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drop_height_above_spawn_point))
data.write(b'\xf52\xb5\xd3') # 0xf532b5d3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dk_pop_effect))
data.write(b'\xca\xa9\xb3\xf5') # 0xcaa9b3f5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.d_kand_diddy_pop_effect))
data.write(b'rl\x83\x9e') # 0x726c839e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dk_pop_sound))
data.write(b'\\lx8') # 0x5c6c7838
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.d_kand_diddy_pop_sound))
data.write(b'\x80i\xfb\xa6') # 0x8069fba6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.balloonless_mode_drop_timer))
@classmethod
def from_json(cls, data: dict):
return cls(
balloon_character=AnimationParameters.from_json(data['balloon_character']),
texture_set=data['texture_set'],
mass=data['mass'],
downward_velocity=data['downward_velocity'],
extra_downward_collision=data['extra_downward_collision'],
dk_riding_offset=Vector.from_json(data['dk_riding_offset']),
start_offset=data['start_offset'],
drop_height_above_spawn_point=data['drop_height_above_spawn_point'],
dk_pop_effect=data['dk_pop_effect'],
d_kand_diddy_pop_effect=data['d_kand_diddy_pop_effect'],
dk_pop_sound=data['dk_pop_sound'],
d_kand_diddy_pop_sound=data['d_kand_diddy_pop_sound'],
balloonless_mode_drop_timer=data['balloonless_mode_drop_timer'],
)
def to_json(self) -> dict:
return {
'balloon_character': self.balloon_character.to_json(),
'texture_set': self.texture_set,
'mass': self.mass,
'downward_velocity': self.downward_velocity,
'extra_downward_collision': self.extra_downward_collision,
'dk_riding_offset': self.dk_riding_offset.to_json(),
'start_offset': self.start_offset,
'drop_height_above_spawn_point': self.drop_height_above_spawn_point,
'dk_pop_effect': self.dk_pop_effect,
'd_kand_diddy_pop_effect': self.d_kand_diddy_pop_effect,
'dk_pop_sound': self.dk_pop_sound,
'd_kand_diddy_pop_sound': self.d_kand_diddy_pop_sound,
'balloonless_mode_drop_timer': self.balloonless_mode_drop_timer,
}
def _decode_balloon_character(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_downward_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_extra_downward_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dk_riding_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_start_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drop_height_above_spawn_point(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dk_pop_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_d_kand_diddy_pop_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dk_pop_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_d_kand_diddy_pop_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_balloonless_mode_drop_timer(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]]] = {
0xf8b3abe0: ('balloon_character', _decode_balloon_character),
0x6b40acef: ('texture_set', _decode_texture_set),
0x75dbb375: ('mass', _decode_mass),
0xddb16979: ('downward_velocity', _decode_downward_velocity),
0x9a27ddc3: ('extra_downward_collision', _decode_extra_downward_collision),
0xc0fe10c6: ('dk_riding_offset', _decode_dk_riding_offset),
0x409618b6: ('start_offset', _decode_start_offset),
0x806178b3: ('drop_height_above_spawn_point', _decode_drop_height_above_spawn_point),
0xf532b5d3: ('dk_pop_effect', _decode_dk_pop_effect),
0xcaa9b3f5: ('d_kand_diddy_pop_effect', _decode_d_kand_diddy_pop_effect),
0x726c839e: ('dk_pop_sound', _decode_dk_pop_sound),
0x5c6c7838: ('d_kand_diddy_pop_sound', _decode_d_kand_diddy_pop_sound),
0x8069fba6: ('balloonless_mode_drop_timer', _decode_balloonless_mode_drop_timer),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BalloonData.py | 0.613815 | 0.245509 | BalloonData.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 SpawnPointData(BaseProperty):
unknown_0x1b92d687: bool = dataclasses.field(default=True)
can_spawn_dk: bool = dataclasses.field(default=True)
can_spawn_diddy: bool = dataclasses.field(default=True)
delete_rambi: bool = dataclasses.field(default=False)
hide_rambi: bool = dataclasses.field(default=False)
unknown_0xebe3bf3f: bool = dataclasses.field(default=False)
unknown_0x0ca54843: bool = dataclasses.field(default=False)
unknown_0xb95c4953: 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'\x1b\x92\xd6\x87') # 0x1b92d687
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x1b92d687))
data.write(b'\xef\xa4$\x18') # 0xefa42418
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_spawn_dk))
data.write(b'j\xb7\x17\xb5') # 0x6ab717b5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_spawn_diddy))
data.write(b'2\x07#\xa9') # 0x320723a9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.delete_rambi))
data.write(b'zb1\xbf') # 0x7a6231bf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hide_rambi))
data.write(b'\xeb\xe3\xbf?') # 0xebe3bf3f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xebe3bf3f))
data.write(b'\x0c\xa5HC') # 0xca54843
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0ca54843))
data.write(b'\xb9\\IS') # 0xb95c4953
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb95c4953))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x1b92d687=data['unknown_0x1b92d687'],
can_spawn_dk=data['can_spawn_dk'],
can_spawn_diddy=data['can_spawn_diddy'],
delete_rambi=data['delete_rambi'],
hide_rambi=data['hide_rambi'],
unknown_0xebe3bf3f=data['unknown_0xebe3bf3f'],
unknown_0x0ca54843=data['unknown_0x0ca54843'],
unknown_0xb95c4953=data['unknown_0xb95c4953'],
)
def to_json(self) -> dict:
return {
'unknown_0x1b92d687': self.unknown_0x1b92d687,
'can_spawn_dk': self.can_spawn_dk,
'can_spawn_diddy': self.can_spawn_diddy,
'delete_rambi': self.delete_rambi,
'hide_rambi': self.hide_rambi,
'unknown_0xebe3bf3f': self.unknown_0xebe3bf3f,
'unknown_0x0ca54843': self.unknown_0x0ca54843,
'unknown_0xb95c4953': self.unknown_0xb95c4953,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1b92d687, 0xefa42418, 0x6ab717b5, 0x320723a9, 0x7a6231bf, 0xebe3bf3f, 0xca54843, 0xb95c4953)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SpawnPointData]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(56))
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 SpawnPointData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_unknown_0x1b92d687(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_spawn_dk(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_spawn_diddy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delete_rambi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hide_rambi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xebe3bf3f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x0ca54843(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb95c4953(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]]] = {
0x1b92d687: ('unknown_0x1b92d687', _decode_unknown_0x1b92d687),
0xefa42418: ('can_spawn_dk', _decode_can_spawn_dk),
0x6ab717b5: ('can_spawn_diddy', _decode_can_spawn_diddy),
0x320723a9: ('delete_rambi', _decode_delete_rambi),
0x7a6231bf: ('hide_rambi', _decode_hide_rambi),
0xebe3bf3f: ('unknown_0xebe3bf3f', _decode_unknown_0xebe3bf3f),
0xca54843: ('unknown_0x0ca54843', _decode_unknown_0x0ca54843),
0xb95c4953: ('unknown_0xb95c4953', _decode_unknown_0xb95c4953),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SpawnPointData.py | 0.543833 | 0.306968 | SpawnPointData.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.JungleBossStructA import JungleBossStructA
@dataclasses.dataclass()
class UnknownStruct203(BaseProperty):
jungle_boss_struct_a_0xd9bba58a: JungleBossStructA = dataclasses.field(default_factory=JungleBossStructA)
jungle_boss_struct_a_0x2bec4872: JungleBossStructA = dataclasses.field(default_factory=JungleBossStructA)
jungle_boss_struct_a_0xccf1eee5: JungleBossStructA = dataclasses.field(default_factory=JungleBossStructA)
@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'\xd9\xbb\xa5\x8a') # 0xd9bba58a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_a_0xd9bba58a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+\xecHr') # 0x2bec4872
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_a_0x2bec4872.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc\xf1\xee\xe5') # 0xccf1eee5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_a_0xccf1eee5.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(
jungle_boss_struct_a_0xd9bba58a=JungleBossStructA.from_json(data['jungle_boss_struct_a_0xd9bba58a']),
jungle_boss_struct_a_0x2bec4872=JungleBossStructA.from_json(data['jungle_boss_struct_a_0x2bec4872']),
jungle_boss_struct_a_0xccf1eee5=JungleBossStructA.from_json(data['jungle_boss_struct_a_0xccf1eee5']),
)
def to_json(self) -> dict:
return {
'jungle_boss_struct_a_0xd9bba58a': self.jungle_boss_struct_a_0xd9bba58a.to_json(),
'jungle_boss_struct_a_0x2bec4872': self.jungle_boss_struct_a_0x2bec4872.to_json(),
'jungle_boss_struct_a_0xccf1eee5': self.jungle_boss_struct_a_0xccf1eee5.to_json(),
}
def _decode_jungle_boss_struct_a_0xd9bba58a(data: typing.BinaryIO, property_size: int):
return JungleBossStructA.from_stream(data, property_size)
def _decode_jungle_boss_struct_a_0x2bec4872(data: typing.BinaryIO, property_size: int):
return JungleBossStructA.from_stream(data, property_size)
def _decode_jungle_boss_struct_a_0xccf1eee5(data: typing.BinaryIO, property_size: int):
return JungleBossStructA.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd9bba58a: ('jungle_boss_struct_a_0xd9bba58a', _decode_jungle_boss_struct_a_0xd9bba58a),
0x2bec4872: ('jungle_boss_struct_a_0x2bec4872', _decode_jungle_boss_struct_a_0x2bec4872),
0xccf1eee5: ('jungle_boss_struct_a_0xccf1eee5', _decode_jungle_boss_struct_a_0xccf1eee5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct203.py | 0.551332 | 0.330363 | UnknownStruct203.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 FollowWaypointsBehaviorData(BaseProperty):
turn_speed: float = dataclasses.field(default=720.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'\x02\x0cx\xbb') # 0x20c78bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
turn_speed=data['turn_speed'],
)
def to_json(self) -> dict:
return {
'turn_speed': self.turn_speed,
}
_FAST_FORMAT = None
_FAST_IDS = (0x20c78bb)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FollowWaypointsBehaviorData]:
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 FollowWaypointsBehaviorData(
dec[2],
)
def _decode_turn_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]]] = {
0x20c78bb: ('turn_speed', _decode_turn_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FollowWaypointsBehaviorData.py | 0.676834 | 0.313039 | FollowWaypointsBehaviorData.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 TouchAttackDirectionEnum(BaseProperty):
attack_direction: enums.AttackDirection = dataclasses.field(default=enums.AttackDirection.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'\x97!\xd0+') # 0x9721d02b
data.write(b'\x00\x04') # size
self.attack_direction.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
attack_direction=enums.AttackDirection.from_json(data['attack_direction']),
)
def to_json(self) -> dict:
return {
'attack_direction': self.attack_direction.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x9721d02b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TouchAttackDirectionEnum]:
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 TouchAttackDirectionEnum(
enums.AttackDirection(dec[2]),
)
def _decode_attack_direction(data: typing.BinaryIO, property_size: int):
return enums.AttackDirection.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9721d02b: ('attack_direction', _decode_attack_direction),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TouchAttackDirectionEnum.py | 0.653901 | 0.304281 | TouchAttackDirectionEnum.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 PlayerFireReactionData(BaseProperty):
gravity_multiplier: float = dataclasses.field(default=1.0)
hurl_height: float = dataclasses.field(default=4.0)
hurl_direction: enums.HurlDirection = dataclasses.field(default=enums.HurlDirection.Unknown2)
hurl_degree_range: float = dataclasses.field(default=0.0)
bounce_count: int = dataclasses.field(default=2)
bounce_value: 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\x06') # 6 properties
data.write(b'B\xacB\xea') # 0x42ac42ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity_multiplier))
data.write(b'\xe2\xa43\x92') # 0xe2a43392
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_height))
data.write(b'\xdaD\x98o') # 0xda44986f
data.write(b'\x00\x04') # size
self.hurl_direction.to_stream(data)
data.write(b'7\x07F\x8e') # 0x3707468e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_degree_range))
data.write(b'\x9d3\x12y') # 0x9d331279
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.bounce_count))
data.write(b'\xd9\x02p\xf8') # 0xd90270f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_value))
@classmethod
def from_json(cls, data: dict):
return cls(
gravity_multiplier=data['gravity_multiplier'],
hurl_height=data['hurl_height'],
hurl_direction=enums.HurlDirection.from_json(data['hurl_direction']),
hurl_degree_range=data['hurl_degree_range'],
bounce_count=data['bounce_count'],
bounce_value=data['bounce_value'],
)
def to_json(self) -> dict:
return {
'gravity_multiplier': self.gravity_multiplier,
'hurl_height': self.hurl_height,
'hurl_direction': self.hurl_direction.to_json(),
'hurl_degree_range': self.hurl_degree_range,
'bounce_count': self.bounce_count,
'bounce_value': self.bounce_value,
}
_FAST_FORMAT = None
_FAST_IDS = (0x42ac42ea, 0xe2a43392, 0xda44986f, 0x3707468e, 0x9d331279, 0xd90270f8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerFireReactionData]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHLLHfLHlLHf')
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 PlayerFireReactionData(
dec[2],
dec[5],
enums.HurlDirection(dec[8]),
dec[11],
dec[14],
dec[17],
)
def _decode_gravity_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_direction(data: typing.BinaryIO, property_size: int):
return enums.HurlDirection.from_stream(data)
def _decode_hurl_degree_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_bounce_value(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]]] = {
0x42ac42ea: ('gravity_multiplier', _decode_gravity_multiplier),
0xe2a43392: ('hurl_height', _decode_hurl_height),
0xda44986f: ('hurl_direction', _decode_hurl_direction),
0x3707468e: ('hurl_degree_range', _decode_hurl_degree_range),
0x9d331279: ('bounce_count', _decode_bounce_count),
0xd90270f8: ('bounce_value', _decode_bounce_value),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerFireReactionData.py | 0.631935 | 0.273053 | PlayerFireReactionData.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.FramingRules import FramingRules
from retro_data_structures.properties.dkc_returns.archetypes.ZoomBehaviorData import ZoomBehaviorData
@dataclasses.dataclass()
class CameraFraming(BaseProperty):
framing_rules: FramingRules = dataclasses.field(default_factory=FramingRules)
zoom_behavior: ZoomBehaviorData = dataclasses.field(default_factory=ZoomBehaviorData)
@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'\xc7\x9a\xa0\xc6') # 0xc79aa0c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.framing_rules.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'b$0\x11') # 0x62243011
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.zoom_behavior.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(
framing_rules=FramingRules.from_json(data['framing_rules']),
zoom_behavior=ZoomBehaviorData.from_json(data['zoom_behavior']),
)
def to_json(self) -> dict:
return {
'framing_rules': self.framing_rules.to_json(),
'zoom_behavior': self.zoom_behavior.to_json(),
}
def _decode_framing_rules(data: typing.BinaryIO, property_size: int):
return FramingRules.from_stream(data, property_size)
def _decode_zoom_behavior(data: typing.BinaryIO, property_size: int):
return ZoomBehaviorData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc79aa0c6: ('framing_rules', _decode_framing_rules),
0x62243011: ('zoom_behavior', _decode_zoom_behavior),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraFraming.py | 0.632843 | 0.297629 | CameraFraming.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.JungleBossStructD import JungleBossStructD
@dataclasses.dataclass()
class UnknownStruct278(BaseProperty):
sequence_size: int = dataclasses.field(default=0)
jungle_boss_struct_d_0x41aca731: JungleBossStructD = dataclasses.field(default_factory=JungleBossStructD)
jungle_boss_struct_d_0x74411162: JungleBossStructD = dataclasses.field(default_factory=JungleBossStructD)
jungle_boss_struct_d_0xd1ca816c: JungleBossStructD = dataclasses.field(default_factory=JungleBossStructD)
jungle_boss_struct_d_0x1f9a7dc4: JungleBossStructD = dataclasses.field(default_factory=JungleBossStructD)
@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'\x1e9\x8c\xb1') # 0x1e398cb1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sequence_size))
data.write(b'A\xac\xa71') # 0x41aca731
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_d_0x41aca731.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'tA\x11b') # 0x74411162
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_d_0x74411162.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1\xca\x81l') # 0xd1ca816c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_d_0xd1ca816c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1f\x9a}\xc4') # 0x1f9a7dc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jungle_boss_struct_d_0x1f9a7dc4.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(
sequence_size=data['sequence_size'],
jungle_boss_struct_d_0x41aca731=JungleBossStructD.from_json(data['jungle_boss_struct_d_0x41aca731']),
jungle_boss_struct_d_0x74411162=JungleBossStructD.from_json(data['jungle_boss_struct_d_0x74411162']),
jungle_boss_struct_d_0xd1ca816c=JungleBossStructD.from_json(data['jungle_boss_struct_d_0xd1ca816c']),
jungle_boss_struct_d_0x1f9a7dc4=JungleBossStructD.from_json(data['jungle_boss_struct_d_0x1f9a7dc4']),
)
def to_json(self) -> dict:
return {
'sequence_size': self.sequence_size,
'jungle_boss_struct_d_0x41aca731': self.jungle_boss_struct_d_0x41aca731.to_json(),
'jungle_boss_struct_d_0x74411162': self.jungle_boss_struct_d_0x74411162.to_json(),
'jungle_boss_struct_d_0xd1ca816c': self.jungle_boss_struct_d_0xd1ca816c.to_json(),
'jungle_boss_struct_d_0x1f9a7dc4': self.jungle_boss_struct_d_0x1f9a7dc4.to_json(),
}
def _decode_sequence_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_jungle_boss_struct_d_0x41aca731(data: typing.BinaryIO, property_size: int):
return JungleBossStructD.from_stream(data, property_size)
def _decode_jungle_boss_struct_d_0x74411162(data: typing.BinaryIO, property_size: int):
return JungleBossStructD.from_stream(data, property_size)
def _decode_jungle_boss_struct_d_0xd1ca816c(data: typing.BinaryIO, property_size: int):
return JungleBossStructD.from_stream(data, property_size)
def _decode_jungle_boss_struct_d_0x1f9a7dc4(data: typing.BinaryIO, property_size: int):
return JungleBossStructD.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1e398cb1: ('sequence_size', _decode_sequence_size),
0x41aca731: ('jungle_boss_struct_d_0x41aca731', _decode_jungle_boss_struct_d_0x41aca731),
0x74411162: ('jungle_boss_struct_d_0x74411162', _decode_jungle_boss_struct_d_0x74411162),
0xd1ca816c: ('jungle_boss_struct_d_0xd1ca816c', _decode_jungle_boss_struct_d_0xd1ca816c),
0x1f9a7dc4: ('jungle_boss_struct_d_0x1f9a7dc4', _decode_jungle_boss_struct_d_0x1f9a7dc4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct278.py | 0.559049 | 0.348257 | UnknownStruct278.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 UnknownStruct243(BaseProperty):
dummy: 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\x01') # 1 properties
data.write(b'\xa04|?') # 0xa0347c3f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.dummy))
@classmethod
def from_json(cls, data: dict):
return cls(
dummy=data['dummy'],
)
def to_json(self) -> dict:
return {
'dummy': self.dummy,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa0347c3f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct243]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(7))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct243(
dec[2],
)
def _decode_dummy(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]]] = {
0xa0347c3f: ('dummy', _decode_dummy),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct243.py | 0.602763 | 0.31008 | UnknownStruct243.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
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 BalloonBarrelData(BaseProperty):
balloon_character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
balloon_attach_locator: str = dataclasses.field(default='')
barrel_attach_locator: str = dataclasses.field(default='')
downward_velocity: float = dataclasses.field(default=3.0)
shake_animation_repeat_time: float = dataclasses.field(default=1.0)
min_horizontal_motion_time: float = dataclasses.field(default=1.0)
max_horizontal_motion_time: float = dataclasses.field(default=2.5)
min_horizontal_motion_velocity: float = dataclasses.field(default=0.5)
max_horizontal_motion_velocity: float = dataclasses.field(default=1.0)
horizontal_motion_acceleration: float = dataclasses.field(default=1.0)
seek_downward_velocity: float = dataclasses.field(default=3.0)
seek_mode_chase_rate: float = dataclasses.field(default=1.5)
seek_minimum_chase_velocity: float = dataclasses.field(default=2.200000047683716)
shake_input_stop_time: float = dataclasses.field(default=0.20000000298023224)
shake_input_resume_time: float = dataclasses.field(default=0.5)
shake_input_time: float = dataclasses.field(default=0.5)
shake_input_speed: Spline = dataclasses.field(default_factory=Spline)
shake_input_target_height_adjust: float = dataclasses.field(default=2.0)
gravity_multiplier: float = dataclasses.field(default=1.0)
extra_downward_collision: float = dataclasses.field(default=3.0)
start_offset: float = dataclasses.field(default=15.0)
below_screen_offset: float = dataclasses.field(default=10.0)
texture_set: int = dataclasses.field(default=0)
pop_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
pop_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
shake_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
offscreen_disappear_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\x1b') # 27 properties
data.write(b'\xf8\xb3\xab\xe0') # 0xf8b3abe0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balloon_character.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82\xde^)') # 0x82de5e29
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.balloon_attach_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'\x16D\xaf\x87') # 0x1644af87
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.barrel_attach_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'\xdd\xb1iy') # 0xddb16979
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.downward_velocity))
data.write(b'+ \x18E') # 0x2b201845
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shake_animation_repeat_time))
data.write(b'\xbfu\xe7\x1f') # 0xbf75e71f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_horizontal_motion_time))
data.write(b'\xe8{\xb7\\') # 0xe87bb75c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_horizontal_motion_time))
data.write(b'\x95E\xf9\xef') # 0x9545f9ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_horizontal_motion_velocity))
data.write(b'\x1b\xd4\xc9U') # 0x1bd4c955
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_horizontal_motion_velocity))
data.write(b'd\xac\xdf{') # 0x64acdf7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horizontal_motion_acceleration))
data.write(b'\xcdn3\xa5') # 0xcd6e33a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.seek_downward_velocity))
data.write(b'\xc3\xcd\xaf\xcb') # 0xc3cdafcb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.seek_mode_chase_rate))
data.write(b'\x88\xbe\xfd\xeb') # 0x88befdeb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.seek_minimum_chase_velocity))
data.write(b'"\x8e\xe6#') # 0x228ee623
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shake_input_stop_time))
data.write(b'~1\x96|') # 0x7e31967c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shake_input_resume_time))
data.write(b'\xdc\xb3\xf5\x0e') # 0xdcb3f50e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shake_input_time))
data.write(b'\xbd\x91p#') # 0xbd917023
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shake_input_speed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|\x84T\xbd') # 0x7c8454bd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shake_input_target_height_adjust))
data.write(b'B\xacB\xea') # 0x42ac42ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity_multiplier))
data.write(b"\x9a'\xdd\xc3") # 0x9a27ddc3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.extra_downward_collision))
data.write(b'@\x96\x18\xb6') # 0x409618b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_offset))
data.write(b'\x0e\xef\xa4x') # 0xeefa478
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.below_screen_offset))
data.write(b'k@\xac\xef') # 0x6b40acef
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.texture_set))
data.write(b'&r\xe0\xbf') # 0x2672e0bf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.pop_effect))
data.write(b'\xe4\xcd\x14\xf9') # 0xe4cd14f9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.pop_sound))
data.write(b'\x1aB)\x94') # 0x1a422994
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.shake_sound))
data.write(b'Y\xcd\x8d\xee') # 0x59cd8dee
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.offscreen_disappear_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
balloon_character=AnimationParameters.from_json(data['balloon_character']),
balloon_attach_locator=data['balloon_attach_locator'],
barrel_attach_locator=data['barrel_attach_locator'],
downward_velocity=data['downward_velocity'],
shake_animation_repeat_time=data['shake_animation_repeat_time'],
min_horizontal_motion_time=data['min_horizontal_motion_time'],
max_horizontal_motion_time=data['max_horizontal_motion_time'],
min_horizontal_motion_velocity=data['min_horizontal_motion_velocity'],
max_horizontal_motion_velocity=data['max_horizontal_motion_velocity'],
horizontal_motion_acceleration=data['horizontal_motion_acceleration'],
seek_downward_velocity=data['seek_downward_velocity'],
seek_mode_chase_rate=data['seek_mode_chase_rate'],
seek_minimum_chase_velocity=data['seek_minimum_chase_velocity'],
shake_input_stop_time=data['shake_input_stop_time'],
shake_input_resume_time=data['shake_input_resume_time'],
shake_input_time=data['shake_input_time'],
shake_input_speed=Spline.from_json(data['shake_input_speed']),
shake_input_target_height_adjust=data['shake_input_target_height_adjust'],
gravity_multiplier=data['gravity_multiplier'],
extra_downward_collision=data['extra_downward_collision'],
start_offset=data['start_offset'],
below_screen_offset=data['below_screen_offset'],
texture_set=data['texture_set'],
pop_effect=data['pop_effect'],
pop_sound=data['pop_sound'],
shake_sound=data['shake_sound'],
offscreen_disappear_sound=data['offscreen_disappear_sound'],
)
def to_json(self) -> dict:
return {
'balloon_character': self.balloon_character.to_json(),
'balloon_attach_locator': self.balloon_attach_locator,
'barrel_attach_locator': self.barrel_attach_locator,
'downward_velocity': self.downward_velocity,
'shake_animation_repeat_time': self.shake_animation_repeat_time,
'min_horizontal_motion_time': self.min_horizontal_motion_time,
'max_horizontal_motion_time': self.max_horizontal_motion_time,
'min_horizontal_motion_velocity': self.min_horizontal_motion_velocity,
'max_horizontal_motion_velocity': self.max_horizontal_motion_velocity,
'horizontal_motion_acceleration': self.horizontal_motion_acceleration,
'seek_downward_velocity': self.seek_downward_velocity,
'seek_mode_chase_rate': self.seek_mode_chase_rate,
'seek_minimum_chase_velocity': self.seek_minimum_chase_velocity,
'shake_input_stop_time': self.shake_input_stop_time,
'shake_input_resume_time': self.shake_input_resume_time,
'shake_input_time': self.shake_input_time,
'shake_input_speed': self.shake_input_speed.to_json(),
'shake_input_target_height_adjust': self.shake_input_target_height_adjust,
'gravity_multiplier': self.gravity_multiplier,
'extra_downward_collision': self.extra_downward_collision,
'start_offset': self.start_offset,
'below_screen_offset': self.below_screen_offset,
'texture_set': self.texture_set,
'pop_effect': self.pop_effect,
'pop_sound': self.pop_sound,
'shake_sound': self.shake_sound,
'offscreen_disappear_sound': self.offscreen_disappear_sound,
}
def _decode_balloon_character(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_balloon_attach_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_barrel_attach_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_downward_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shake_animation_repeat_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_horizontal_motion_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_horizontal_motion_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_horizontal_motion_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_horizontal_motion_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horizontal_motion_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_seek_downward_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_seek_mode_chase_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_seek_minimum_chase_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shake_input_stop_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shake_input_resume_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shake_input_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shake_input_speed(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_shake_input_target_height_adjust(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_extra_downward_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_below_screen_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_pop_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_pop_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_shake_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_offscreen_disappear_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]]] = {
0xf8b3abe0: ('balloon_character', _decode_balloon_character),
0x82de5e29: ('balloon_attach_locator', _decode_balloon_attach_locator),
0x1644af87: ('barrel_attach_locator', _decode_barrel_attach_locator),
0xddb16979: ('downward_velocity', _decode_downward_velocity),
0x2b201845: ('shake_animation_repeat_time', _decode_shake_animation_repeat_time),
0xbf75e71f: ('min_horizontal_motion_time', _decode_min_horizontal_motion_time),
0xe87bb75c: ('max_horizontal_motion_time', _decode_max_horizontal_motion_time),
0x9545f9ef: ('min_horizontal_motion_velocity', _decode_min_horizontal_motion_velocity),
0x1bd4c955: ('max_horizontal_motion_velocity', _decode_max_horizontal_motion_velocity),
0x64acdf7b: ('horizontal_motion_acceleration', _decode_horizontal_motion_acceleration),
0xcd6e33a5: ('seek_downward_velocity', _decode_seek_downward_velocity),
0xc3cdafcb: ('seek_mode_chase_rate', _decode_seek_mode_chase_rate),
0x88befdeb: ('seek_minimum_chase_velocity', _decode_seek_minimum_chase_velocity),
0x228ee623: ('shake_input_stop_time', _decode_shake_input_stop_time),
0x7e31967c: ('shake_input_resume_time', _decode_shake_input_resume_time),
0xdcb3f50e: ('shake_input_time', _decode_shake_input_time),
0xbd917023: ('shake_input_speed', _decode_shake_input_speed),
0x7c8454bd: ('shake_input_target_height_adjust', _decode_shake_input_target_height_adjust),
0x42ac42ea: ('gravity_multiplier', _decode_gravity_multiplier),
0x9a27ddc3: ('extra_downward_collision', _decode_extra_downward_collision),
0x409618b6: ('start_offset', _decode_start_offset),
0xeefa478: ('below_screen_offset', _decode_below_screen_offset),
0x6b40acef: ('texture_set', _decode_texture_set),
0x2672e0bf: ('pop_effect', _decode_pop_effect),
0xe4cd14f9: ('pop_sound', _decode_pop_sound),
0x1a422994: ('shake_sound', _decode_shake_sound),
0x59cd8dee: ('offscreen_disappear_sound', _decode_offscreen_disappear_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BalloonBarrelData.py | 0.625438 | 0.216322 | BalloonBarrelData.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 DKBarrelGlueData(BaseProperty):
dk_inside_animation: int = dataclasses.field(default=0)
diddy_inside_animation: int = dataclasses.field(default=0)
dk_held_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
diddy_held_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
held_sound_initial_delay: float = dataclasses.field(default=0.0)
held_sound_random_delay_min: float = dataclasses.field(default=0.0)
held_sound_random_delay_max: 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\x07') # 7 properties
data.write(b'\x1cu\xf2M') # 0x1c75f24d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.dk_inside_animation))
data.write(b'\x0c\\l\xd8') # 0xc5c6cd8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.diddy_inside_animation))
data.write(b'\xe8E\xac\x92') # 0xe845ac92
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.dk_held_sound))
data.write(b'\x16\xad\x04#') # 0x16ad0423
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.diddy_held_sound))
data.write(b'\xf8\xe9Ia') # 0xf8e94961
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.held_sound_initial_delay))
data.write(b'\x7fT\x97\xb7') # 0x7f5497b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.held_sound_random_delay_min))
data.write(b'\x9948V') # 0x99343856
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.held_sound_random_delay_max))
@classmethod
def from_json(cls, data: dict):
return cls(
dk_inside_animation=data['dk_inside_animation'],
diddy_inside_animation=data['diddy_inside_animation'],
dk_held_sound=data['dk_held_sound'],
diddy_held_sound=data['diddy_held_sound'],
held_sound_initial_delay=data['held_sound_initial_delay'],
held_sound_random_delay_min=data['held_sound_random_delay_min'],
held_sound_random_delay_max=data['held_sound_random_delay_max'],
)
def to_json(self) -> dict:
return {
'dk_inside_animation': self.dk_inside_animation,
'diddy_inside_animation': self.diddy_inside_animation,
'dk_held_sound': self.dk_held_sound,
'diddy_held_sound': self.diddy_held_sound,
'held_sound_initial_delay': self.held_sound_initial_delay,
'held_sound_random_delay_min': self.held_sound_random_delay_min,
'held_sound_random_delay_max': self.held_sound_random_delay_max,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1c75f24d, 0xc5c6cd8, 0xe845ac92, 0x16ad0423, 0xf8e94961, 0x7f5497b7, 0x99343856)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DKBarrelGlueData]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHQLHQLHfLHfLHf')
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]) != _FAST_IDS:
data.seek(before)
return None
return DKBarrelGlueData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_dk_inside_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_diddy_inside_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dk_held_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_diddy_held_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_held_sound_initial_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_held_sound_random_delay_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_held_sound_random_delay_max(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]]] = {
0x1c75f24d: ('dk_inside_animation', _decode_dk_inside_animation),
0xc5c6cd8: ('diddy_inside_animation', _decode_diddy_inside_animation),
0xe845ac92: ('dk_held_sound', _decode_dk_held_sound),
0x16ad0423: ('diddy_held_sound', _decode_diddy_held_sound),
0xf8e94961: ('held_sound_initial_delay', _decode_held_sound_initial_delay),
0x7f5497b7: ('held_sound_random_delay_min', _decode_held_sound_random_delay_min),
0x99343856: ('held_sound_random_delay_max', _decode_held_sound_random_delay_max),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DKBarrelGlueData.py | 0.609757 | 0.182899 | DKBarrelGlueData.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 UnknownStruct160(BaseProperty):
unknown: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
cine_lever: 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]
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'\xe0\xc6u\x93') # 0xe0c67593
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown))
data.write(b'\xd9\xbe\xd8\xd3') # 0xd9bed8d3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cine_lever))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
cine_lever=data['cine_lever'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'cine_lever': self.cine_lever,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe0c67593, 0xd9bed8d3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct160]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(28))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct160(
dec[2],
dec[5],
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cine_lever(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]]] = {
0xe0c67593: ('unknown', _decode_unknown),
0xd9bed8d3: ('cine_lever', _decode_cine_lever),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct160.py | 0.620047 | 0.235878 | UnknownStruct160.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 UnknownStruct88(BaseProperty):
transition_time: float = dataclasses.field(default=0.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]
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'\x182\x93^') # 0x1832935e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.transition_time))
@classmethod
def from_json(cls, data: dict):
return cls(
transition_time=data['transition_time'],
)
def to_json(self) -> dict:
return {
'transition_time': self.transition_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1832935e)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct88]:
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 UnknownStruct88(
dec[2],
)
def _decode_transition_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]]] = {
0x1832935e: ('transition_time', _decode_transition_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct88.py | 0.668556 | 0.304003 | UnknownStruct88.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.DamageInfo import DamageInfo
@dataclasses.dataclass()
class GrabPlayerBehaviorData(BaseProperty):
grab_player_type: enums.GrabPlayerType = dataclasses.field(default=enums.GrabPlayerType.Unknown1)
chew_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
chew_damage_time: float = dataclasses.field(default=3.0)
chew_damage_on_spit_out: bool = dataclasses.field(default=False)
chew_damage_on_spit_out_delay_time: float = dataclasses.field(default=0.375)
ground_pound_let_go_time: float = dataclasses.field(default=1.0)
ground_pound_relapse_multiplier: float = dataclasses.field(default=1.0)
ground_pound_window: float = dataclasses.field(default=0.20000000298023224)
attract_target_speed: float = dataclasses.field(default=12.0)
grab_distance_threshold: float = dataclasses.field(default=0.5)
post_release_ignore_time: float = dataclasses.field(default=0.30000001192092896)
spit_distance: float = dataclasses.field(default=0.0)
spit_height: float = dataclasses.field(default=6.0)
spit_speed: float = dataclasses.field(default=3.0)
vine_ignore_time: float = dataclasses.field(default=2.0)
vine_swing_dampen_time: float = dataclasses.field(default=1.0)
vine_swing_undampen_time: 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]
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'\xbf\x89\xd0]') # 0xbf89d05d
data.write(b'\x00\x04') # size
self.grab_player_type.to_stream(data)
data.write(b'oz4\x16') # 0x6f7a3416
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.chew_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'&~\xdd\x84') # 0x267edd84
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chew_damage_time))
data.write(b'K\xce\xf9\x1a') # 0x4bcef91a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.chew_damage_on_spit_out))
data.write(b'\xc7\x93\xc5%') # 0xc793c525
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chew_damage_on_spit_out_delay_time))
data.write(b'\xce{\t\xc8') # 0xce7b09c8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_let_go_time))
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'h\xd7\x87\xb4') # 0x68d787b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_window))
data.write(b'#\x07\xa9\x92') # 0x2307a992
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attract_target_speed))
data.write(b'y\xfa\xd0\xa2') # 0x79fad0a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grab_distance_threshold))
data.write(b'o\xca\xf0h') # 0x6fcaf068
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.post_release_ignore_time))
data.write(b'\x04@\x8eG') # 0x4408e47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_distance))
data.write(b'\xa5K\xe65') # 0xa54be635
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_height))
data.write(b'K=\xb4\xd5') # 0x4b3db4d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spit_speed))
data.write(b'\xbf\x7f<\xd1') # 0xbf7f3cd1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vine_ignore_time))
data.write(b'`F\xee\x04') # 0x6046ee04
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vine_swing_dampen_time))
data.write(b'0\xac\x88l') # 0x30ac886c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vine_swing_undampen_time))
@classmethod
def from_json(cls, data: dict):
return cls(
grab_player_type=enums.GrabPlayerType.from_json(data['grab_player_type']),
chew_damage=DamageInfo.from_json(data['chew_damage']),
chew_damage_time=data['chew_damage_time'],
chew_damage_on_spit_out=data['chew_damage_on_spit_out'],
chew_damage_on_spit_out_delay_time=data['chew_damage_on_spit_out_delay_time'],
ground_pound_let_go_time=data['ground_pound_let_go_time'],
ground_pound_relapse_multiplier=data['ground_pound_relapse_multiplier'],
ground_pound_window=data['ground_pound_window'],
attract_target_speed=data['attract_target_speed'],
grab_distance_threshold=data['grab_distance_threshold'],
post_release_ignore_time=data['post_release_ignore_time'],
spit_distance=data['spit_distance'],
spit_height=data['spit_height'],
spit_speed=data['spit_speed'],
vine_ignore_time=data['vine_ignore_time'],
vine_swing_dampen_time=data['vine_swing_dampen_time'],
vine_swing_undampen_time=data['vine_swing_undampen_time'],
)
def to_json(self) -> dict:
return {
'grab_player_type': self.grab_player_type.to_json(),
'chew_damage': self.chew_damage.to_json(),
'chew_damage_time': self.chew_damage_time,
'chew_damage_on_spit_out': self.chew_damage_on_spit_out,
'chew_damage_on_spit_out_delay_time': self.chew_damage_on_spit_out_delay_time,
'ground_pound_let_go_time': self.ground_pound_let_go_time,
'ground_pound_relapse_multiplier': self.ground_pound_relapse_multiplier,
'ground_pound_window': self.ground_pound_window,
'attract_target_speed': self.attract_target_speed,
'grab_distance_threshold': self.grab_distance_threshold,
'post_release_ignore_time': self.post_release_ignore_time,
'spit_distance': self.spit_distance,
'spit_height': self.spit_height,
'spit_speed': self.spit_speed,
'vine_ignore_time': self.vine_ignore_time,
'vine_swing_dampen_time': self.vine_swing_dampen_time,
'vine_swing_undampen_time': self.vine_swing_undampen_time,
}
def _decode_grab_player_type(data: typing.BinaryIO, property_size: int):
return enums.GrabPlayerType.from_stream(data)
def _decode_chew_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_chew_damage_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chew_damage_on_spit_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_chew_damage_on_spit_out_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_pound_let_go_time(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_ground_pound_window(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attract_target_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grab_distance_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_post_release_ignore_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spit_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vine_ignore_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vine_swing_dampen_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vine_swing_undampen_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]]] = {
0xbf89d05d: ('grab_player_type', _decode_grab_player_type),
0x6f7a3416: ('chew_damage', _decode_chew_damage),
0x267edd84: ('chew_damage_time', _decode_chew_damage_time),
0x4bcef91a: ('chew_damage_on_spit_out', _decode_chew_damage_on_spit_out),
0xc793c525: ('chew_damage_on_spit_out_delay_time', _decode_chew_damage_on_spit_out_delay_time),
0xce7b09c8: ('ground_pound_let_go_time', _decode_ground_pound_let_go_time),
0x686e030b: ('ground_pound_relapse_multiplier', _decode_ground_pound_relapse_multiplier),
0x68d787b4: ('ground_pound_window', _decode_ground_pound_window),
0x2307a992: ('attract_target_speed', _decode_attract_target_speed),
0x79fad0a2: ('grab_distance_threshold', _decode_grab_distance_threshold),
0x6fcaf068: ('post_release_ignore_time', _decode_post_release_ignore_time),
0x4408e47: ('spit_distance', _decode_spit_distance),
0xa54be635: ('spit_height', _decode_spit_height),
0x4b3db4d5: ('spit_speed', _decode_spit_speed),
0xbf7f3cd1: ('vine_ignore_time', _decode_vine_ignore_time),
0x6046ee04: ('vine_swing_dampen_time', _decode_vine_swing_dampen_time),
0x30ac886c: ('vine_swing_undampen_time', _decode_vine_swing_undampen_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GrabPlayerBehaviorData.py | 0.559049 | 0.308972 | GrabPlayerBehaviorData.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.OceanBridgeStructA import OceanBridgeStructA
from retro_data_structures.properties.dkc_returns.archetypes.OceanBridgeStructB import OceanBridgeStructB
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 OceanBridgeData(BaseProperty):
unknown_0xe993145f: int = dataclasses.field(default=0)
cmdl_0x69a2b08e: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
cmdl_0xa2fe632b: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
alt_model2: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0xef36c220: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0xf233f298: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
z_motion: Spline = dataclasses.field(default_factory=Spline)
y_rotation: Spline = dataclasses.field(default_factory=Spline)
impulse_time_min: float = dataclasses.field(default=-0.10000000149011612)
impulse_time_max: float = dataclasses.field(default=0.25)
impulse_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x6045bb7b: int = dataclasses.field(default=4)
unknown_0xfe69d67a: float = dataclasses.field(default=0.05000000074505806)
unknown_0x847759ba: float = dataclasses.field(default=12.0)
rise_min: float = dataclasses.field(default=0.75)
rise_max: float = dataclasses.field(default=2.5)
rise_step: float = dataclasses.field(default=0.5)
target_height: float = dataclasses.field(default=7.0)
unknown_0x75ce0c79: float = dataclasses.field(default=7.0)
unknown_0xe5d866f1: bool = dataclasses.field(default=False)
unknown_0xb0946259: bool = dataclasses.field(default=True)
unknown_0x812afc85: bool = dataclasses.field(default=True)
unknown_0x66ad2b98: float = dataclasses.field(default=0.10000000149011612)
unknown_0x1d2d962d: float = dataclasses.field(default=10.0)
center_plank: int = dataclasses.field(default=2)
rotate_plank0: bool = dataclasses.field(default=False)
rotate_plank1: bool = dataclasses.field(default=False)
rotate_plank2: bool = dataclasses.field(default=False)
rotate_plank3: bool = dataclasses.field(default=False)
rotate_plank4: bool = dataclasses.field(default=False)
rotate_plank5: bool = dataclasses.field(default=False)
rotate_plank6: bool = dataclasses.field(default=False)
rotate_plank7: bool = dataclasses.field(default=False)
rotate_plank8: bool = dataclasses.field(default=False)
rotate_plank9: bool = dataclasses.field(default=False)
unknown_0xe6b1d780: bool = dataclasses.field(default=False)
unknown_0xdbd1fe30: bool = dataclasses.field(default=False)
unknown_0x9c7184e0: bool = dataclasses.field(default=False)
unknown_0xa111ad50: bool = dataclasses.field(default=False)
unknown_0x13317140: bool = dataclasses.field(default=False)
unknown_0x2e5158f0: bool = dataclasses.field(default=False)
unknown_0x69f12220: bool = dataclasses.field(default=False)
unknown_0x54910b90: bool = dataclasses.field(default=False)
unknown_0xd6c19c41: bool = dataclasses.field(default=False)
unknown_0xeba1b5f1: bool = dataclasses.field(default=False)
ocean_bridge_struct_a_0x66a86577: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0xfddb8fa3: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x8b3eb69e: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x104d5c4a: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x66f4c4e4: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0xfd872e30: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x8b62170d: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x1011fdd9: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x66112651: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0xfd62cc85: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x17a09d5f: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x8cd3778b: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0xfa364eb6: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x6145a462: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x17fc3ccc: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x8c8fd618: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0xfa6aef25: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x611905f1: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x1719de79: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_a_0x8c6a34ad: OceanBridgeStructA = dataclasses.field(default_factory=OceanBridgeStructA)
ocean_bridge_struct_b_0xdafe5d7a: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x418db7ae: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x37688e93: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xac1b6447: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xdaa2fce9: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x41d1163d: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x37342f00: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xac47c5d4: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xda471e5c: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x4134f488: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x3ce60d48: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xa795e79c: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xd170dea1: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x4a033475: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x3cbaacdb: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xa7c9460f: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xd12c7f32: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x4a5f95e6: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0x3c5f4e6e: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
ocean_bridge_struct_b_0xa72ca4ba: OceanBridgeStructB = dataclasses.field(default_factory=OceanBridgeStructB)
sfx_volume: float = dataclasses.field(default=1.0)
caud_0xe7ca6050: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x5d4fbc07: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x0ed5e783: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
caud_0xa3bac487: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x4fe79727: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x1c7dcca3: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
caud_0x51ed297f: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0xeaeffc4b: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xb975a7cf: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
caud_0xb6f08fe8: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x89e8256f: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xda727eeb: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
caud_0x6e33f4ce: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x7b8e2cd2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x28147756: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x0093800d: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0xccbb7330: Spline = dataclasses.field(default_factory=Spline)
unknown_0xaa62345f: Spline = dataclasses.field(default_factory=Spline)
unknown_0x1852af24: Spline = dataclasses.field(default_factory=Spline)
unknown_0x0ba9a91c: Spline = dataclasses.field(default_factory=Spline)
unknown_0x6fcc7dd4: Spline = dataclasses.field(default_factory=Spline)
unknown_0x77c88cc7: Spline = dataclasses.field(default_factory=Spline)
unknown_0x7b066bac: Spline = dataclasses.field(default_factory=Spline)
unknown_0x64fadea2: Spline = dataclasses.field(default_factory=Spline)
caud_0x751bfe84: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
acceptable_vascular: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x3dba2f5c: 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'\x00r') # 114 properties
data.write(b'\xe9\x93\x14_') # 0xe993145f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe993145f))
data.write(b'i\xa2\xb0\x8e') # 0x69a2b08e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cmdl_0x69a2b08e))
data.write(b'\xa2\xfec+') # 0xa2fe632b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cmdl_0xa2fe632b))
data.write(b'$j\x11\x85') # 0x246a1185
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.alt_model2))
data.write(b'\xef6\xc2 ') # 0xef36c220
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xef36c220))
data.write(b'\xf23\xf2\x98') # 0xf233f298
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xf233f298))
data.write(b'\xf7\xaa_2') # 0xf7aa5f32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_motion.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'V\x88h;') # 0x5688683b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impulse_time_min))
data.write(b'\xb0\xe8\xc7\xda') # 0xb0e8c7da
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impulse_time_max))
data.write(b'##\xba\x82') # 0x2323ba82
data.write(b'\x00\x0c') # size
self.impulse_offset.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'`E\xbb{') # 0x6045bb7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6045bb7b))
data.write(b'\xfei\xd6z') # 0xfe69d67a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfe69d67a))
data.write(b'\x84wY\xba') # 0x847759ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x847759ba))
data.write(b'\xe5\xb6\xb6f') # 0xe5b6b666
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rise_min))
data.write(b'\x03\xd6\x19\x87') # 0x3d61987
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rise_max))
data.write(b'\xc2F\xb3\xca') # 0xc246b3ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rise_step))
data.write(b'\xbd\xba\x19\x1e') # 0xbdba191e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_height))
data.write(b'u\xce\x0cy') # 0x75ce0c79
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x75ce0c79))
data.write(b'\xe5\xd8f\xf1') # 0xe5d866f1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe5d866f1))
data.write(b'\xb0\x94bY') # 0xb0946259
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb0946259))
data.write(b'\x81*\xfc\x85') # 0x812afc85
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x812afc85))
data.write(b'f\xad+\x98') # 0x66ad2b98
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x66ad2b98))
data.write(b'\x1d-\x96-') # 0x1d2d962d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1d2d962d))
data.write(b'\x9d\xee4z') # 0x9dee347a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.center_plank))
data.write(b'\x1f>\xadS') # 0x1f3ead53
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank0))
data.write(b'"^\x84\xe3') # 0x225e84e3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank1))
data.write(b'e\xfe\xfe3') # 0x65fefe33
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank2))
data.write(b'X\x9e\xd7\x83') # 0x589ed783
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank3))
data.write(b'\xea\xbe\x0b\x93') # 0xeabe0b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank4))
data.write(b'\xd7\xde"#') # 0xd7de2223
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank5))
data.write(b'\x90~X\xf3') # 0x907e58f3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank6))
data.write(b'\xad\x1eqC') # 0xad1e7143
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank7))
data.write(b'/N\xe6\x92') # 0x2f4ee692
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank8))
data.write(b'\x12.\xcf"') # 0x122ecf22
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate_plank9))
data.write(b'\xe6\xb1\xd7\x80') # 0xe6b1d780
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe6b1d780))
data.write(b'\xdb\xd1\xfe0') # 0xdbd1fe30
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xdbd1fe30))
data.write(b'\x9cq\x84\xe0') # 0x9c7184e0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x9c7184e0))
data.write(b'\xa1\x11\xadP') # 0xa111ad50
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa111ad50))
data.write(b'\x131q@') # 0x13317140
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x13317140))
data.write(b'.QX\xf0') # 0x2e5158f0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2e5158f0))
data.write(b'i\xf1" ') # 0x69f12220
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x69f12220))
data.write(b'T\x91\x0b\x90') # 0x54910b90
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x54910b90))
data.write(b'\xd6\xc1\x9cA') # 0xd6c19c41
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd6c19c41))
data.write(b'\xeb\xa1\xb5\xf1') # 0xeba1b5f1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xeba1b5f1))
data.write(b'f\xa8ew') # 0x66a86577
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x66a86577.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\xdb\x8f\xa3') # 0xfddb8fa3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0xfddb8fa3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b>\xb6\x9e') # 0x8b3eb69e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x8b3eb69e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10M\\J') # 0x104d5c4a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x104d5c4a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\xf4\xc4\xe4') # 0x66f4c4e4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x66f4c4e4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x87.0') # 0xfd872e30
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0xfd872e30.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8bb\x17\r') # 0x8b62170d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x8b62170d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10\x11\xfd\xd9') # 0x1011fdd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x1011fdd9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\x11&Q') # 0x66112651
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x66112651.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfdb\xcc\x85') # 0xfd62cc85
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0xfd62cc85.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xa0\x9d_') # 0x17a09d5f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x17a09d5f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c\xd3w\x8b') # 0x8cd3778b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x8cd3778b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa6N\xb6') # 0xfa364eb6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0xfa364eb6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'aE\xa4b') # 0x6145a462
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x6145a462.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xfc<\xcc') # 0x17fc3ccc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x17fc3ccc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c\x8f\xd6\x18') # 0x8c8fd618
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x8c8fd618.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfaj\xef%') # 0xfa6aef25
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0xfa6aef25.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\x19\x05\xf1') # 0x611905f1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x611905f1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\x19\xdey') # 0x1719de79
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x1719de79.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8cj4\xad') # 0x8c6a34ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_a_0x8c6a34ad.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xda\xfe]z') # 0xdafe5d7a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xdafe5d7a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A\x8d\xb7\xae') # 0x418db7ae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x418db7ae.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7h\x8e\x93') # 0x37688e93
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x37688e93.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xac\x1bdG') # 0xac1b6447
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xac1b6447.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xda\xa2\xfc\xe9') # 0xdaa2fce9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xdaa2fce9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A\xd1\x16=') # 0x41d1163d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x41d1163d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'74/\x00') # 0x37342f00
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x37342f00.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xacG\xc5\xd4') # 0xac47c5d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xac47c5d4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdaG\x1e\\') # 0xda471e5c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xda471e5c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A4\xf4\x88') # 0x4134f488
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x4134f488.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<\xe6\rH') # 0x3ce60d48
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x3ce60d48.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7\x95\xe7\x9c') # 0xa795e79c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xa795e79c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1p\xde\xa1') # 0xd170dea1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xd170dea1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\x034u') # 0x4a033475
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x4a033475.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<\xba\xac\xdb') # 0x3cbaacdb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x3cbaacdb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7\xc9F\x0f') # 0xa7c9460f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xa7c9460f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1,\x7f2') # 0xd12c7f32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xd12c7f32.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J_\x95\xe6') # 0x4a5f95e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x4a5f95e6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<_Nn') # 0x3c5f4e6e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0x3c5f4e6e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7,\xa4\xba') # 0xa72ca4ba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_bridge_struct_b_0xa72ca4ba.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\xa1%m') # 0xaaa1256d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.sfx_volume))
data.write(b'\xe7\xca`P') # 0xe7ca6050
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xe7ca6050))
data.write(b']O\xbc\x07') # 0x5d4fbc07
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x5d4fbc07))
data.write(b'\x0e\xd5\xe7\x83') # 0xed5e783
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x0ed5e783))
data.write(b'\xa3\xba\xc4\x87') # 0xa3bac487
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xa3bac487))
data.write(b"O\xe7\x97'") # 0x4fe79727
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x4fe79727))
data.write(b'\x1c}\xcc\xa3') # 0x1c7dcca3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x1c7dcca3))
data.write(b'Q\xed)\x7f') # 0x51ed297f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x51ed297f))
data.write(b'\xea\xef\xfcK') # 0xeaeffc4b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xeaeffc4b))
data.write(b'\xb9u\xa7\xcf') # 0xb975a7cf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xb975a7cf))
data.write(b'\xb6\xf0\x8f\xe8') # 0xb6f08fe8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xb6f08fe8))
data.write(b'\x89\xe8%o') # 0x89e8256f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x89e8256f))
data.write(b'\xdar~\xeb') # 0xda727eeb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xda727eeb))
data.write(b'n3\xf4\xce') # 0x6e33f4ce
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x6e33f4ce))
data.write(b'{\x8e,\xd2') # 0x7b8e2cd2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x7b8e2cd2))
data.write(b'(\x14wV') # 0x28147756
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x28147756))
data.write(b'\x00\x93\x80\r') # 0x93800d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x0093800d))
data.write(b'\xcc\xbbs0') # 0xccbb7330
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xccbb7330.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaab4_') # 0xaa62345f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xaa62345f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18R\xaf$') # 0x1852af24
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1852af24.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0b\xa9\xa9\x1c') # 0xba9a91c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x0ba9a91c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'o\xcc}\xd4') # 0x6fcc7dd4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x6fcc7dd4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\xc8\x8c\xc7') # 0x77c88cc7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x77c88cc7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{\x06k\xac') # 0x7b066bac
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7b066bac.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xfa\xde\xa2') # 0x64fadea2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x64fadea2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'u\x1b\xfe\x84') # 0x751bfe84
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x751bfe84))
data.write(b'^\xb1\x13\xbf') # 0x5eb113bf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.acceptable_vascular))
data.write(b'=\xba/\\') # 0x3dba2f5c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x3dba2f5c))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xe993145f=data['unknown_0xe993145f'],
cmdl_0x69a2b08e=data['cmdl_0x69a2b08e'],
cmdl_0xa2fe632b=data['cmdl_0xa2fe632b'],
alt_model2=data['alt_model2'],
unknown_0xef36c220=data['unknown_0xef36c220'],
unknown_0xf233f298=data['unknown_0xf233f298'],
z_motion=Spline.from_json(data['z_motion']),
y_rotation=Spline.from_json(data['y_rotation']),
impulse_time_min=data['impulse_time_min'],
impulse_time_max=data['impulse_time_max'],
impulse_offset=Vector.from_json(data['impulse_offset']),
collision_offset=Vector.from_json(data['collision_offset']),
unknown_0x6045bb7b=data['unknown_0x6045bb7b'],
unknown_0xfe69d67a=data['unknown_0xfe69d67a'],
unknown_0x847759ba=data['unknown_0x847759ba'],
rise_min=data['rise_min'],
rise_max=data['rise_max'],
rise_step=data['rise_step'],
target_height=data['target_height'],
unknown_0x75ce0c79=data['unknown_0x75ce0c79'],
unknown_0xe5d866f1=data['unknown_0xe5d866f1'],
unknown_0xb0946259=data['unknown_0xb0946259'],
unknown_0x812afc85=data['unknown_0x812afc85'],
unknown_0x66ad2b98=data['unknown_0x66ad2b98'],
unknown_0x1d2d962d=data['unknown_0x1d2d962d'],
center_plank=data['center_plank'],
rotate_plank0=data['rotate_plank0'],
rotate_plank1=data['rotate_plank1'],
rotate_plank2=data['rotate_plank2'],
rotate_plank3=data['rotate_plank3'],
rotate_plank4=data['rotate_plank4'],
rotate_plank5=data['rotate_plank5'],
rotate_plank6=data['rotate_plank6'],
rotate_plank7=data['rotate_plank7'],
rotate_plank8=data['rotate_plank8'],
rotate_plank9=data['rotate_plank9'],
unknown_0xe6b1d780=data['unknown_0xe6b1d780'],
unknown_0xdbd1fe30=data['unknown_0xdbd1fe30'],
unknown_0x9c7184e0=data['unknown_0x9c7184e0'],
unknown_0xa111ad50=data['unknown_0xa111ad50'],
unknown_0x13317140=data['unknown_0x13317140'],
unknown_0x2e5158f0=data['unknown_0x2e5158f0'],
unknown_0x69f12220=data['unknown_0x69f12220'],
unknown_0x54910b90=data['unknown_0x54910b90'],
unknown_0xd6c19c41=data['unknown_0xd6c19c41'],
unknown_0xeba1b5f1=data['unknown_0xeba1b5f1'],
ocean_bridge_struct_a_0x66a86577=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x66a86577']),
ocean_bridge_struct_a_0xfddb8fa3=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0xfddb8fa3']),
ocean_bridge_struct_a_0x8b3eb69e=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x8b3eb69e']),
ocean_bridge_struct_a_0x104d5c4a=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x104d5c4a']),
ocean_bridge_struct_a_0x66f4c4e4=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x66f4c4e4']),
ocean_bridge_struct_a_0xfd872e30=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0xfd872e30']),
ocean_bridge_struct_a_0x8b62170d=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x8b62170d']),
ocean_bridge_struct_a_0x1011fdd9=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x1011fdd9']),
ocean_bridge_struct_a_0x66112651=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x66112651']),
ocean_bridge_struct_a_0xfd62cc85=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0xfd62cc85']),
ocean_bridge_struct_a_0x17a09d5f=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x17a09d5f']),
ocean_bridge_struct_a_0x8cd3778b=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x8cd3778b']),
ocean_bridge_struct_a_0xfa364eb6=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0xfa364eb6']),
ocean_bridge_struct_a_0x6145a462=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x6145a462']),
ocean_bridge_struct_a_0x17fc3ccc=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x17fc3ccc']),
ocean_bridge_struct_a_0x8c8fd618=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x8c8fd618']),
ocean_bridge_struct_a_0xfa6aef25=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0xfa6aef25']),
ocean_bridge_struct_a_0x611905f1=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x611905f1']),
ocean_bridge_struct_a_0x1719de79=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x1719de79']),
ocean_bridge_struct_a_0x8c6a34ad=OceanBridgeStructA.from_json(data['ocean_bridge_struct_a_0x8c6a34ad']),
ocean_bridge_struct_b_0xdafe5d7a=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xdafe5d7a']),
ocean_bridge_struct_b_0x418db7ae=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x418db7ae']),
ocean_bridge_struct_b_0x37688e93=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x37688e93']),
ocean_bridge_struct_b_0xac1b6447=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xac1b6447']),
ocean_bridge_struct_b_0xdaa2fce9=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xdaa2fce9']),
ocean_bridge_struct_b_0x41d1163d=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x41d1163d']),
ocean_bridge_struct_b_0x37342f00=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x37342f00']),
ocean_bridge_struct_b_0xac47c5d4=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xac47c5d4']),
ocean_bridge_struct_b_0xda471e5c=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xda471e5c']),
ocean_bridge_struct_b_0x4134f488=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x4134f488']),
ocean_bridge_struct_b_0x3ce60d48=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x3ce60d48']),
ocean_bridge_struct_b_0xa795e79c=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xa795e79c']),
ocean_bridge_struct_b_0xd170dea1=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xd170dea1']),
ocean_bridge_struct_b_0x4a033475=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x4a033475']),
ocean_bridge_struct_b_0x3cbaacdb=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x3cbaacdb']),
ocean_bridge_struct_b_0xa7c9460f=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xa7c9460f']),
ocean_bridge_struct_b_0xd12c7f32=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xd12c7f32']),
ocean_bridge_struct_b_0x4a5f95e6=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x4a5f95e6']),
ocean_bridge_struct_b_0x3c5f4e6e=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0x3c5f4e6e']),
ocean_bridge_struct_b_0xa72ca4ba=OceanBridgeStructB.from_json(data['ocean_bridge_struct_b_0xa72ca4ba']),
sfx_volume=data['sfx_volume'],
caud_0xe7ca6050=data['caud_0xe7ca6050'],
caud_0x5d4fbc07=data['caud_0x5d4fbc07'],
unknown_0x0ed5e783=data['unknown_0x0ed5e783'],
caud_0xa3bac487=data['caud_0xa3bac487'],
caud_0x4fe79727=data['caud_0x4fe79727'],
unknown_0x1c7dcca3=data['unknown_0x1c7dcca3'],
caud_0x51ed297f=data['caud_0x51ed297f'],
caud_0xeaeffc4b=data['caud_0xeaeffc4b'],
unknown_0xb975a7cf=data['unknown_0xb975a7cf'],
caud_0xb6f08fe8=data['caud_0xb6f08fe8'],
caud_0x89e8256f=data['caud_0x89e8256f'],
unknown_0xda727eeb=data['unknown_0xda727eeb'],
caud_0x6e33f4ce=data['caud_0x6e33f4ce'],
caud_0x7b8e2cd2=data['caud_0x7b8e2cd2'],
unknown_0x28147756=data['unknown_0x28147756'],
unknown_0x0093800d=data['unknown_0x0093800d'],
unknown_0xccbb7330=Spline.from_json(data['unknown_0xccbb7330']),
unknown_0xaa62345f=Spline.from_json(data['unknown_0xaa62345f']),
unknown_0x1852af24=Spline.from_json(data['unknown_0x1852af24']),
unknown_0x0ba9a91c=Spline.from_json(data['unknown_0x0ba9a91c']),
unknown_0x6fcc7dd4=Spline.from_json(data['unknown_0x6fcc7dd4']),
unknown_0x77c88cc7=Spline.from_json(data['unknown_0x77c88cc7']),
unknown_0x7b066bac=Spline.from_json(data['unknown_0x7b066bac']),
unknown_0x64fadea2=Spline.from_json(data['unknown_0x64fadea2']),
caud_0x751bfe84=data['caud_0x751bfe84'],
acceptable_vascular=data['acceptable_vascular'],
caud_0x3dba2f5c=data['caud_0x3dba2f5c'],
)
def to_json(self) -> dict:
return {
'unknown_0xe993145f': self.unknown_0xe993145f,
'cmdl_0x69a2b08e': self.cmdl_0x69a2b08e,
'cmdl_0xa2fe632b': self.cmdl_0xa2fe632b,
'alt_model2': self.alt_model2,
'unknown_0xef36c220': self.unknown_0xef36c220,
'unknown_0xf233f298': self.unknown_0xf233f298,
'z_motion': self.z_motion.to_json(),
'y_rotation': self.y_rotation.to_json(),
'impulse_time_min': self.impulse_time_min,
'impulse_time_max': self.impulse_time_max,
'impulse_offset': self.impulse_offset.to_json(),
'collision_offset': self.collision_offset.to_json(),
'unknown_0x6045bb7b': self.unknown_0x6045bb7b,
'unknown_0xfe69d67a': self.unknown_0xfe69d67a,
'unknown_0x847759ba': self.unknown_0x847759ba,
'rise_min': self.rise_min,
'rise_max': self.rise_max,
'rise_step': self.rise_step,
'target_height': self.target_height,
'unknown_0x75ce0c79': self.unknown_0x75ce0c79,
'unknown_0xe5d866f1': self.unknown_0xe5d866f1,
'unknown_0xb0946259': self.unknown_0xb0946259,
'unknown_0x812afc85': self.unknown_0x812afc85,
'unknown_0x66ad2b98': self.unknown_0x66ad2b98,
'unknown_0x1d2d962d': self.unknown_0x1d2d962d,
'center_plank': self.center_plank,
'rotate_plank0': self.rotate_plank0,
'rotate_plank1': self.rotate_plank1,
'rotate_plank2': self.rotate_plank2,
'rotate_plank3': self.rotate_plank3,
'rotate_plank4': self.rotate_plank4,
'rotate_plank5': self.rotate_plank5,
'rotate_plank6': self.rotate_plank6,
'rotate_plank7': self.rotate_plank7,
'rotate_plank8': self.rotate_plank8,
'rotate_plank9': self.rotate_plank9,
'unknown_0xe6b1d780': self.unknown_0xe6b1d780,
'unknown_0xdbd1fe30': self.unknown_0xdbd1fe30,
'unknown_0x9c7184e0': self.unknown_0x9c7184e0,
'unknown_0xa111ad50': self.unknown_0xa111ad50,
'unknown_0x13317140': self.unknown_0x13317140,
'unknown_0x2e5158f0': self.unknown_0x2e5158f0,
'unknown_0x69f12220': self.unknown_0x69f12220,
'unknown_0x54910b90': self.unknown_0x54910b90,
'unknown_0xd6c19c41': self.unknown_0xd6c19c41,
'unknown_0xeba1b5f1': self.unknown_0xeba1b5f1,
'ocean_bridge_struct_a_0x66a86577': self.ocean_bridge_struct_a_0x66a86577.to_json(),
'ocean_bridge_struct_a_0xfddb8fa3': self.ocean_bridge_struct_a_0xfddb8fa3.to_json(),
'ocean_bridge_struct_a_0x8b3eb69e': self.ocean_bridge_struct_a_0x8b3eb69e.to_json(),
'ocean_bridge_struct_a_0x104d5c4a': self.ocean_bridge_struct_a_0x104d5c4a.to_json(),
'ocean_bridge_struct_a_0x66f4c4e4': self.ocean_bridge_struct_a_0x66f4c4e4.to_json(),
'ocean_bridge_struct_a_0xfd872e30': self.ocean_bridge_struct_a_0xfd872e30.to_json(),
'ocean_bridge_struct_a_0x8b62170d': self.ocean_bridge_struct_a_0x8b62170d.to_json(),
'ocean_bridge_struct_a_0x1011fdd9': self.ocean_bridge_struct_a_0x1011fdd9.to_json(),
'ocean_bridge_struct_a_0x66112651': self.ocean_bridge_struct_a_0x66112651.to_json(),
'ocean_bridge_struct_a_0xfd62cc85': self.ocean_bridge_struct_a_0xfd62cc85.to_json(),
'ocean_bridge_struct_a_0x17a09d5f': self.ocean_bridge_struct_a_0x17a09d5f.to_json(),
'ocean_bridge_struct_a_0x8cd3778b': self.ocean_bridge_struct_a_0x8cd3778b.to_json(),
'ocean_bridge_struct_a_0xfa364eb6': self.ocean_bridge_struct_a_0xfa364eb6.to_json(),
'ocean_bridge_struct_a_0x6145a462': self.ocean_bridge_struct_a_0x6145a462.to_json(),
'ocean_bridge_struct_a_0x17fc3ccc': self.ocean_bridge_struct_a_0x17fc3ccc.to_json(),
'ocean_bridge_struct_a_0x8c8fd618': self.ocean_bridge_struct_a_0x8c8fd618.to_json(),
'ocean_bridge_struct_a_0xfa6aef25': self.ocean_bridge_struct_a_0xfa6aef25.to_json(),
'ocean_bridge_struct_a_0x611905f1': self.ocean_bridge_struct_a_0x611905f1.to_json(),
'ocean_bridge_struct_a_0x1719de79': self.ocean_bridge_struct_a_0x1719de79.to_json(),
'ocean_bridge_struct_a_0x8c6a34ad': self.ocean_bridge_struct_a_0x8c6a34ad.to_json(),
'ocean_bridge_struct_b_0xdafe5d7a': self.ocean_bridge_struct_b_0xdafe5d7a.to_json(),
'ocean_bridge_struct_b_0x418db7ae': self.ocean_bridge_struct_b_0x418db7ae.to_json(),
'ocean_bridge_struct_b_0x37688e93': self.ocean_bridge_struct_b_0x37688e93.to_json(),
'ocean_bridge_struct_b_0xac1b6447': self.ocean_bridge_struct_b_0xac1b6447.to_json(),
'ocean_bridge_struct_b_0xdaa2fce9': self.ocean_bridge_struct_b_0xdaa2fce9.to_json(),
'ocean_bridge_struct_b_0x41d1163d': self.ocean_bridge_struct_b_0x41d1163d.to_json(),
'ocean_bridge_struct_b_0x37342f00': self.ocean_bridge_struct_b_0x37342f00.to_json(),
'ocean_bridge_struct_b_0xac47c5d4': self.ocean_bridge_struct_b_0xac47c5d4.to_json(),
'ocean_bridge_struct_b_0xda471e5c': self.ocean_bridge_struct_b_0xda471e5c.to_json(),
'ocean_bridge_struct_b_0x4134f488': self.ocean_bridge_struct_b_0x4134f488.to_json(),
'ocean_bridge_struct_b_0x3ce60d48': self.ocean_bridge_struct_b_0x3ce60d48.to_json(),
'ocean_bridge_struct_b_0xa795e79c': self.ocean_bridge_struct_b_0xa795e79c.to_json(),
'ocean_bridge_struct_b_0xd170dea1': self.ocean_bridge_struct_b_0xd170dea1.to_json(),
'ocean_bridge_struct_b_0x4a033475': self.ocean_bridge_struct_b_0x4a033475.to_json(),
'ocean_bridge_struct_b_0x3cbaacdb': self.ocean_bridge_struct_b_0x3cbaacdb.to_json(),
'ocean_bridge_struct_b_0xa7c9460f': self.ocean_bridge_struct_b_0xa7c9460f.to_json(),
'ocean_bridge_struct_b_0xd12c7f32': self.ocean_bridge_struct_b_0xd12c7f32.to_json(),
'ocean_bridge_struct_b_0x4a5f95e6': self.ocean_bridge_struct_b_0x4a5f95e6.to_json(),
'ocean_bridge_struct_b_0x3c5f4e6e': self.ocean_bridge_struct_b_0x3c5f4e6e.to_json(),
'ocean_bridge_struct_b_0xa72ca4ba': self.ocean_bridge_struct_b_0xa72ca4ba.to_json(),
'sfx_volume': self.sfx_volume,
'caud_0xe7ca6050': self.caud_0xe7ca6050,
'caud_0x5d4fbc07': self.caud_0x5d4fbc07,
'unknown_0x0ed5e783': self.unknown_0x0ed5e783,
'caud_0xa3bac487': self.caud_0xa3bac487,
'caud_0x4fe79727': self.caud_0x4fe79727,
'unknown_0x1c7dcca3': self.unknown_0x1c7dcca3,
'caud_0x51ed297f': self.caud_0x51ed297f,
'caud_0xeaeffc4b': self.caud_0xeaeffc4b,
'unknown_0xb975a7cf': self.unknown_0xb975a7cf,
'caud_0xb6f08fe8': self.caud_0xb6f08fe8,
'caud_0x89e8256f': self.caud_0x89e8256f,
'unknown_0xda727eeb': self.unknown_0xda727eeb,
'caud_0x6e33f4ce': self.caud_0x6e33f4ce,
'caud_0x7b8e2cd2': self.caud_0x7b8e2cd2,
'unknown_0x28147756': self.unknown_0x28147756,
'unknown_0x0093800d': self.unknown_0x0093800d,
'unknown_0xccbb7330': self.unknown_0xccbb7330.to_json(),
'unknown_0xaa62345f': self.unknown_0xaa62345f.to_json(),
'unknown_0x1852af24': self.unknown_0x1852af24.to_json(),
'unknown_0x0ba9a91c': self.unknown_0x0ba9a91c.to_json(),
'unknown_0x6fcc7dd4': self.unknown_0x6fcc7dd4.to_json(),
'unknown_0x77c88cc7': self.unknown_0x77c88cc7.to_json(),
'unknown_0x7b066bac': self.unknown_0x7b066bac.to_json(),
'unknown_0x64fadea2': self.unknown_0x64fadea2.to_json(),
'caud_0x751bfe84': self.caud_0x751bfe84,
'acceptable_vascular': self.acceptable_vascular,
'caud_0x3dba2f5c': self.caud_0x3dba2f5c,
}
def _decode_unknown_0xe993145f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_cmdl_0x69a2b08e(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cmdl_0xa2fe632b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_alt_model2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xef36c220(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xf233f298(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_z_motion(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_impulse_time_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impulse_time_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impulse_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x6045bb7b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xfe69d67a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x847759ba(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rise_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rise_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rise_step(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]
def _decode_unknown_0x75ce0c79(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe5d866f1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb0946259(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x812afc85(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x66ad2b98(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1d2d962d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_center_plank(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_rotate_plank0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rotate_plank9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe6b1d780(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xdbd1fe30(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x9c7184e0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa111ad50(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x13317140(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2e5158f0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x69f12220(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x54910b90(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xd6c19c41(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xeba1b5f1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ocean_bridge_struct_a_0x66a86577(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0xfddb8fa3(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x8b3eb69e(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x104d5c4a(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x66f4c4e4(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0xfd872e30(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x8b62170d(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x1011fdd9(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x66112651(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0xfd62cc85(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x17a09d5f(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x8cd3778b(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0xfa364eb6(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x6145a462(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x17fc3ccc(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x8c8fd618(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0xfa6aef25(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x611905f1(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x1719de79(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_a_0x8c6a34ad(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructA.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xdafe5d7a(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x418db7ae(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x37688e93(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xac1b6447(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xdaa2fce9(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x41d1163d(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x37342f00(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xac47c5d4(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xda471e5c(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x4134f488(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x3ce60d48(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xa795e79c(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xd170dea1(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x4a033475(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x3cbaacdb(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xa7c9460f(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xd12c7f32(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x4a5f95e6(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0x3c5f4e6e(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_ocean_bridge_struct_b_0xa72ca4ba(data: typing.BinaryIO, property_size: int):
return OceanBridgeStructB.from_stream(data, property_size)
def _decode_sfx_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_caud_0xe7ca6050(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x5d4fbc07(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x0ed5e783(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0xa3bac487(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x4fe79727(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x1c7dcca3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x51ed297f(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0xeaeffc4b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xb975a7cf(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0xb6f08fe8(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x89e8256f(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xda727eeb(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x6e33f4ce(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x7b8e2cd2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x28147756(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x0093800d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xccbb7330(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0xaa62345f(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x1852af24(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x0ba9a91c(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x6fcc7dd4(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x77c88cc7(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x7b066bac(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x64fadea2(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_caud_0x751bfe84(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_acceptable_vascular(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x3dba2f5c(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]]] = {
0xe993145f: ('unknown_0xe993145f', _decode_unknown_0xe993145f),
0x69a2b08e: ('cmdl_0x69a2b08e', _decode_cmdl_0x69a2b08e),
0xa2fe632b: ('cmdl_0xa2fe632b', _decode_cmdl_0xa2fe632b),
0x246a1185: ('alt_model2', _decode_alt_model2),
0xef36c220: ('unknown_0xef36c220', _decode_unknown_0xef36c220),
0xf233f298: ('unknown_0xf233f298', _decode_unknown_0xf233f298),
0xf7aa5f32: ('z_motion', _decode_z_motion),
0xd0239f95: ('y_rotation', _decode_y_rotation),
0x5688683b: ('impulse_time_min', _decode_impulse_time_min),
0xb0e8c7da: ('impulse_time_max', _decode_impulse_time_max),
0x2323ba82: ('impulse_offset', _decode_impulse_offset),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x6045bb7b: ('unknown_0x6045bb7b', _decode_unknown_0x6045bb7b),
0xfe69d67a: ('unknown_0xfe69d67a', _decode_unknown_0xfe69d67a),
0x847759ba: ('unknown_0x847759ba', _decode_unknown_0x847759ba),
0xe5b6b666: ('rise_min', _decode_rise_min),
0x3d61987: ('rise_max', _decode_rise_max),
0xc246b3ca: ('rise_step', _decode_rise_step),
0xbdba191e: ('target_height', _decode_target_height),
0x75ce0c79: ('unknown_0x75ce0c79', _decode_unknown_0x75ce0c79),
0xe5d866f1: ('unknown_0xe5d866f1', _decode_unknown_0xe5d866f1),
0xb0946259: ('unknown_0xb0946259', _decode_unknown_0xb0946259),
0x812afc85: ('unknown_0x812afc85', _decode_unknown_0x812afc85),
0x66ad2b98: ('unknown_0x66ad2b98', _decode_unknown_0x66ad2b98),
0x1d2d962d: ('unknown_0x1d2d962d', _decode_unknown_0x1d2d962d),
0x9dee347a: ('center_plank', _decode_center_plank),
0x1f3ead53: ('rotate_plank0', _decode_rotate_plank0),
0x225e84e3: ('rotate_plank1', _decode_rotate_plank1),
0x65fefe33: ('rotate_plank2', _decode_rotate_plank2),
0x589ed783: ('rotate_plank3', _decode_rotate_plank3),
0xeabe0b93: ('rotate_plank4', _decode_rotate_plank4),
0xd7de2223: ('rotate_plank5', _decode_rotate_plank5),
0x907e58f3: ('rotate_plank6', _decode_rotate_plank6),
0xad1e7143: ('rotate_plank7', _decode_rotate_plank7),
0x2f4ee692: ('rotate_plank8', _decode_rotate_plank8),
0x122ecf22: ('rotate_plank9', _decode_rotate_plank9),
0xe6b1d780: ('unknown_0xe6b1d780', _decode_unknown_0xe6b1d780),
0xdbd1fe30: ('unknown_0xdbd1fe30', _decode_unknown_0xdbd1fe30),
0x9c7184e0: ('unknown_0x9c7184e0', _decode_unknown_0x9c7184e0),
0xa111ad50: ('unknown_0xa111ad50', _decode_unknown_0xa111ad50),
0x13317140: ('unknown_0x13317140', _decode_unknown_0x13317140),
0x2e5158f0: ('unknown_0x2e5158f0', _decode_unknown_0x2e5158f0),
0x69f12220: ('unknown_0x69f12220', _decode_unknown_0x69f12220),
0x54910b90: ('unknown_0x54910b90', _decode_unknown_0x54910b90),
0xd6c19c41: ('unknown_0xd6c19c41', _decode_unknown_0xd6c19c41),
0xeba1b5f1: ('unknown_0xeba1b5f1', _decode_unknown_0xeba1b5f1),
0x66a86577: ('ocean_bridge_struct_a_0x66a86577', _decode_ocean_bridge_struct_a_0x66a86577),
0xfddb8fa3: ('ocean_bridge_struct_a_0xfddb8fa3', _decode_ocean_bridge_struct_a_0xfddb8fa3),
0x8b3eb69e: ('ocean_bridge_struct_a_0x8b3eb69e', _decode_ocean_bridge_struct_a_0x8b3eb69e),
0x104d5c4a: ('ocean_bridge_struct_a_0x104d5c4a', _decode_ocean_bridge_struct_a_0x104d5c4a),
0x66f4c4e4: ('ocean_bridge_struct_a_0x66f4c4e4', _decode_ocean_bridge_struct_a_0x66f4c4e4),
0xfd872e30: ('ocean_bridge_struct_a_0xfd872e30', _decode_ocean_bridge_struct_a_0xfd872e30),
0x8b62170d: ('ocean_bridge_struct_a_0x8b62170d', _decode_ocean_bridge_struct_a_0x8b62170d),
0x1011fdd9: ('ocean_bridge_struct_a_0x1011fdd9', _decode_ocean_bridge_struct_a_0x1011fdd9),
0x66112651: ('ocean_bridge_struct_a_0x66112651', _decode_ocean_bridge_struct_a_0x66112651),
0xfd62cc85: ('ocean_bridge_struct_a_0xfd62cc85', _decode_ocean_bridge_struct_a_0xfd62cc85),
0x17a09d5f: ('ocean_bridge_struct_a_0x17a09d5f', _decode_ocean_bridge_struct_a_0x17a09d5f),
0x8cd3778b: ('ocean_bridge_struct_a_0x8cd3778b', _decode_ocean_bridge_struct_a_0x8cd3778b),
0xfa364eb6: ('ocean_bridge_struct_a_0xfa364eb6', _decode_ocean_bridge_struct_a_0xfa364eb6),
0x6145a462: ('ocean_bridge_struct_a_0x6145a462', _decode_ocean_bridge_struct_a_0x6145a462),
0x17fc3ccc: ('ocean_bridge_struct_a_0x17fc3ccc', _decode_ocean_bridge_struct_a_0x17fc3ccc),
0x8c8fd618: ('ocean_bridge_struct_a_0x8c8fd618', _decode_ocean_bridge_struct_a_0x8c8fd618),
0xfa6aef25: ('ocean_bridge_struct_a_0xfa6aef25', _decode_ocean_bridge_struct_a_0xfa6aef25),
0x611905f1: ('ocean_bridge_struct_a_0x611905f1', _decode_ocean_bridge_struct_a_0x611905f1),
0x1719de79: ('ocean_bridge_struct_a_0x1719de79', _decode_ocean_bridge_struct_a_0x1719de79),
0x8c6a34ad: ('ocean_bridge_struct_a_0x8c6a34ad', _decode_ocean_bridge_struct_a_0x8c6a34ad),
0xdafe5d7a: ('ocean_bridge_struct_b_0xdafe5d7a', _decode_ocean_bridge_struct_b_0xdafe5d7a),
0x418db7ae: ('ocean_bridge_struct_b_0x418db7ae', _decode_ocean_bridge_struct_b_0x418db7ae),
0x37688e93: ('ocean_bridge_struct_b_0x37688e93', _decode_ocean_bridge_struct_b_0x37688e93),
0xac1b6447: ('ocean_bridge_struct_b_0xac1b6447', _decode_ocean_bridge_struct_b_0xac1b6447),
0xdaa2fce9: ('ocean_bridge_struct_b_0xdaa2fce9', _decode_ocean_bridge_struct_b_0xdaa2fce9),
0x41d1163d: ('ocean_bridge_struct_b_0x41d1163d', _decode_ocean_bridge_struct_b_0x41d1163d),
0x37342f00: ('ocean_bridge_struct_b_0x37342f00', _decode_ocean_bridge_struct_b_0x37342f00),
0xac47c5d4: ('ocean_bridge_struct_b_0xac47c5d4', _decode_ocean_bridge_struct_b_0xac47c5d4),
0xda471e5c: ('ocean_bridge_struct_b_0xda471e5c', _decode_ocean_bridge_struct_b_0xda471e5c),
0x4134f488: ('ocean_bridge_struct_b_0x4134f488', _decode_ocean_bridge_struct_b_0x4134f488),
0x3ce60d48: ('ocean_bridge_struct_b_0x3ce60d48', _decode_ocean_bridge_struct_b_0x3ce60d48),
0xa795e79c: ('ocean_bridge_struct_b_0xa795e79c', _decode_ocean_bridge_struct_b_0xa795e79c),
0xd170dea1: ('ocean_bridge_struct_b_0xd170dea1', _decode_ocean_bridge_struct_b_0xd170dea1),
0x4a033475: ('ocean_bridge_struct_b_0x4a033475', _decode_ocean_bridge_struct_b_0x4a033475),
0x3cbaacdb: ('ocean_bridge_struct_b_0x3cbaacdb', _decode_ocean_bridge_struct_b_0x3cbaacdb),
0xa7c9460f: ('ocean_bridge_struct_b_0xa7c9460f', _decode_ocean_bridge_struct_b_0xa7c9460f),
0xd12c7f32: ('ocean_bridge_struct_b_0xd12c7f32', _decode_ocean_bridge_struct_b_0xd12c7f32),
0x4a5f95e6: ('ocean_bridge_struct_b_0x4a5f95e6', _decode_ocean_bridge_struct_b_0x4a5f95e6),
0x3c5f4e6e: ('ocean_bridge_struct_b_0x3c5f4e6e', _decode_ocean_bridge_struct_b_0x3c5f4e6e),
0xa72ca4ba: ('ocean_bridge_struct_b_0xa72ca4ba', _decode_ocean_bridge_struct_b_0xa72ca4ba),
0xaaa1256d: ('sfx_volume', _decode_sfx_volume),
0xe7ca6050: ('caud_0xe7ca6050', _decode_caud_0xe7ca6050),
0x5d4fbc07: ('caud_0x5d4fbc07', _decode_caud_0x5d4fbc07),
0xed5e783: ('unknown_0x0ed5e783', _decode_unknown_0x0ed5e783),
0xa3bac487: ('caud_0xa3bac487', _decode_caud_0xa3bac487),
0x4fe79727: ('caud_0x4fe79727', _decode_caud_0x4fe79727),
0x1c7dcca3: ('unknown_0x1c7dcca3', _decode_unknown_0x1c7dcca3),
0x51ed297f: ('caud_0x51ed297f', _decode_caud_0x51ed297f),
0xeaeffc4b: ('caud_0xeaeffc4b', _decode_caud_0xeaeffc4b),
0xb975a7cf: ('unknown_0xb975a7cf', _decode_unknown_0xb975a7cf),
0xb6f08fe8: ('caud_0xb6f08fe8', _decode_caud_0xb6f08fe8),
0x89e8256f: ('caud_0x89e8256f', _decode_caud_0x89e8256f),
0xda727eeb: ('unknown_0xda727eeb', _decode_unknown_0xda727eeb),
0x6e33f4ce: ('caud_0x6e33f4ce', _decode_caud_0x6e33f4ce),
0x7b8e2cd2: ('caud_0x7b8e2cd2', _decode_caud_0x7b8e2cd2),
0x28147756: ('unknown_0x28147756', _decode_unknown_0x28147756),
0x93800d: ('unknown_0x0093800d', _decode_unknown_0x0093800d),
0xccbb7330: ('unknown_0xccbb7330', _decode_unknown_0xccbb7330),
0xaa62345f: ('unknown_0xaa62345f', _decode_unknown_0xaa62345f),
0x1852af24: ('unknown_0x1852af24', _decode_unknown_0x1852af24),
0xba9a91c: ('unknown_0x0ba9a91c', _decode_unknown_0x0ba9a91c),
0x6fcc7dd4: ('unknown_0x6fcc7dd4', _decode_unknown_0x6fcc7dd4),
0x77c88cc7: ('unknown_0x77c88cc7', _decode_unknown_0x77c88cc7),
0x7b066bac: ('unknown_0x7b066bac', _decode_unknown_0x7b066bac),
0x64fadea2: ('unknown_0x64fadea2', _decode_unknown_0x64fadea2),
0x751bfe84: ('caud_0x751bfe84', _decode_caud_0x751bfe84),
0x5eb113bf: ('acceptable_vascular', _decode_acceptable_vascular),
0x3dba2f5c: ('caud_0x3dba2f5c', _decode_caud_0x3dba2f5c),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OceanBridgeData.py | 0.662141 | 0.159938 | OceanBridgeData.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.RobotChickenFlyerStructB import RobotChickenFlyerStructB
@dataclasses.dataclass()
class UnknownStruct261(BaseProperty):
attack_selector: enums.RobotChickenEnum = dataclasses.field(default=enums.RobotChickenEnum.Unknown1)
health: float = dataclasses.field(default=3.0)
robot_chicken_flyer_struct_b_0x002cfe87: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
robot_chicken_flyer_struct_b_0x76c9c7ba: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
robot_chicken_flyer_struct_b_0xedba2d6e: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
robot_chicken_flyer_struct_b_0x9b03b5c0: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
robot_chicken_flyer_struct_b_0x00705f14: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
robot_chicken_flyer_struct_b_0x76956629: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
robot_chicken_flyer_struct_b_0xede68cfd: RobotChickenFlyerStructB = dataclasses.field(default_factory=RobotChickenFlyerStructB)
@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'\x00,\xfe\x87') # 0x2cfe87
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0x002cfe87.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\xc9\xc7\xba') # 0x76c9c7ba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0x76c9c7ba.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xba-n') # 0xedba2d6e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0xedba2d6e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9b\x03\xb5\xc0') # 0x9b03b5c0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0x9b03b5c0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00p_\x14') # 0x705f14
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0x00705f14.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\x95f)') # 0x76956629
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0x76956629.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xe6\x8c\xfd') # 0xede68cfd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_flyer_struct_b_0xede68cfd.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'],
robot_chicken_flyer_struct_b_0x002cfe87=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0x002cfe87']),
robot_chicken_flyer_struct_b_0x76c9c7ba=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0x76c9c7ba']),
robot_chicken_flyer_struct_b_0xedba2d6e=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0xedba2d6e']),
robot_chicken_flyer_struct_b_0x9b03b5c0=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0x9b03b5c0']),
robot_chicken_flyer_struct_b_0x00705f14=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0x00705f14']),
robot_chicken_flyer_struct_b_0x76956629=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0x76956629']),
robot_chicken_flyer_struct_b_0xede68cfd=RobotChickenFlyerStructB.from_json(data['robot_chicken_flyer_struct_b_0xede68cfd']),
)
def to_json(self) -> dict:
return {
'attack_selector': self.attack_selector.to_json(),
'health': self.health,
'robot_chicken_flyer_struct_b_0x002cfe87': self.robot_chicken_flyer_struct_b_0x002cfe87.to_json(),
'robot_chicken_flyer_struct_b_0x76c9c7ba': self.robot_chicken_flyer_struct_b_0x76c9c7ba.to_json(),
'robot_chicken_flyer_struct_b_0xedba2d6e': self.robot_chicken_flyer_struct_b_0xedba2d6e.to_json(),
'robot_chicken_flyer_struct_b_0x9b03b5c0': self.robot_chicken_flyer_struct_b_0x9b03b5c0.to_json(),
'robot_chicken_flyer_struct_b_0x00705f14': self.robot_chicken_flyer_struct_b_0x00705f14.to_json(),
'robot_chicken_flyer_struct_b_0x76956629': self.robot_chicken_flyer_struct_b_0x76956629.to_json(),
'robot_chicken_flyer_struct_b_0xede68cfd': self.robot_chicken_flyer_struct_b_0xede68cfd.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_robot_chicken_flyer_struct_b_0x002cfe87(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_b_0x76c9c7ba(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_b_0xedba2d6e(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_b_0x9b03b5c0(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_b_0x00705f14(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_b_0x76956629(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.from_stream(data, property_size)
def _decode_robot_chicken_flyer_struct_b_0xede68cfd(data: typing.BinaryIO, property_size: int):
return RobotChickenFlyerStructB.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),
0x2cfe87: ('robot_chicken_flyer_struct_b_0x002cfe87', _decode_robot_chicken_flyer_struct_b_0x002cfe87),
0x76c9c7ba: ('robot_chicken_flyer_struct_b_0x76c9c7ba', _decode_robot_chicken_flyer_struct_b_0x76c9c7ba),
0xedba2d6e: ('robot_chicken_flyer_struct_b_0xedba2d6e', _decode_robot_chicken_flyer_struct_b_0xedba2d6e),
0x9b03b5c0: ('robot_chicken_flyer_struct_b_0x9b03b5c0', _decode_robot_chicken_flyer_struct_b_0x9b03b5c0),
0x705f14: ('robot_chicken_flyer_struct_b_0x00705f14', _decode_robot_chicken_flyer_struct_b_0x00705f14),
0x76956629: ('robot_chicken_flyer_struct_b_0x76956629', _decode_robot_chicken_flyer_struct_b_0x76956629),
0xede68cfd: ('robot_chicken_flyer_struct_b_0xede68cfd', _decode_robot_chicken_flyer_struct_b_0xede68cfd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct261.py | 0.517815 | 0.299681 | UnknownStruct261.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.UnknownStruct231 import UnknownStruct231
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct235 import UnknownStruct235
@dataclasses.dataclass()
class UnknownStruct236(BaseProperty):
mole_type: enums.MoleType = dataclasses.field(default=enums.MoleType.Unknown1)
damage_bounds_scale_z: float = dataclasses.field(default=0.5)
unknown: str = dataclasses.field(default='')
unknown_struct231: UnknownStruct231 = dataclasses.field(default_factory=UnknownStruct231)
unknown_struct235: UnknownStruct235 = dataclasses.field(default_factory=UnknownStruct235)
@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'\xe9s!\x10') # 0xe9732110
data.write(b'\x00\x04') # size
self.mole_type.to_stream(data)
data.write(b'\xc36\xa4\xef') # 0xc336a4ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_bounds_scale_z))
data.write(b'\x15\x87\x08E') # 0x15870845
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'Fs\xc9<') # 0x4673c93c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct231.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa6\x94\xe8\xca') # 0xa694e8ca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct235.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(
mole_type=enums.MoleType.from_json(data['mole_type']),
damage_bounds_scale_z=data['damage_bounds_scale_z'],
unknown=data['unknown'],
unknown_struct231=UnknownStruct231.from_json(data['unknown_struct231']),
unknown_struct235=UnknownStruct235.from_json(data['unknown_struct235']),
)
def to_json(self) -> dict:
return {
'mole_type': self.mole_type.to_json(),
'damage_bounds_scale_z': self.damage_bounds_scale_z,
'unknown': self.unknown,
'unknown_struct231': self.unknown_struct231.to_json(),
'unknown_struct235': self.unknown_struct235.to_json(),
}
def _decode_mole_type(data: typing.BinaryIO, property_size: int):
return enums.MoleType.from_stream(data)
def _decode_damage_bounds_scale_z(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[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_unknown_struct231(data: typing.BinaryIO, property_size: int):
return UnknownStruct231.from_stream(data, property_size)
def _decode_unknown_struct235(data: typing.BinaryIO, property_size: int):
return UnknownStruct235.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe9732110: ('mole_type', _decode_mole_type),
0xc336a4ef: ('damage_bounds_scale_z', _decode_damage_bounds_scale_z),
0x15870845: ('unknown', _decode_unknown),
0x4673c93c: ('unknown_struct231', _decode_unknown_struct231),
0xa694e8ca: ('unknown_struct235', _decode_unknown_struct235),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct236.py | 0.640748 | 0.281714 | UnknownStruct236.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 MaterialType(BaseProperty):
material_type: enums.UnknownEnum1 = dataclasses.field(default=enums.UnknownEnum1.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'\x95\xa6\x8dL') # 0x95a68d4c
data.write(b'\x00\x04') # size
self.material_type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
material_type=enums.UnknownEnum1.from_json(data['material_type']),
)
def to_json(self) -> dict:
return {
'material_type': self.material_type.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x95a68d4c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MaterialType]:
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 MaterialType(
enums.UnknownEnum1(dec[2]),
)
def _decode_material_type(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum1.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x95a68d4c: ('material_type', _decode_material_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MaterialType.py | 0.642881 | 0.280368 | MaterialType.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 UnknownStruct270(BaseProperty):
allow_ground_pound: bool = dataclasses.field(default=False)
allow_peanut_gun: 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\x02') # 2 properties
data.write(b'\xbdERd') # 0xbd455264
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_ground_pound))
data.write(b'\xd1\x14\xb7]') # 0xd114b75d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_peanut_gun))
@classmethod
def from_json(cls, data: dict):
return cls(
allow_ground_pound=data['allow_ground_pound'],
allow_peanut_gun=data['allow_peanut_gun'],
)
def to_json(self) -> dict:
return {
'allow_ground_pound': self.allow_ground_pound,
'allow_peanut_gun': self.allow_peanut_gun,
}
_FAST_FORMAT = None
_FAST_IDS = (0xbd455264, 0xd114b75d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct270]:
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 UnknownStruct270(
dec[2],
dec[5],
)
def _decode_allow_ground_pound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_peanut_gun(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]]] = {
0xbd455264: ('allow_ground_pound', _decode_allow_ground_pound),
0xd114b75d: ('allow_peanut_gun', _decode_allow_peanut_gun),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct270.py | 0.60054 | 0.311859 | UnknownStruct270.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 UnknownStruct67(BaseProperty):
offset: Spline = dataclasses.field(default_factory=Spline)
unknown: 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]
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'osh\xe0') # 0x6f7368e0
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'\xd2\x1cb\xff') # 0xd21c62ff
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
offset=Spline.from_json(data['offset']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'offset': self.offset.to_json(),
'unknown': self.unknown,
}
def _decode_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
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]]] = {
0x6f7368e0: ('offset', _decode_offset),
0xd21c62ff: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct67.py | 0.627837 | 0.288114 | UnknownStruct67.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 UnknownStruct54(BaseProperty):
attack_type: enums.AttackType = dataclasses.field(default=enums.AttackType.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'\x07\xd99\xa1') # 0x7d939a1
data.write(b'\x00\x04') # size
self.attack_type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
attack_type=enums.AttackType.from_json(data['attack_type']),
)
def to_json(self) -> dict:
return {
'attack_type': self.attack_type.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x7d939a1)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct54]:
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 UnknownStruct54(
enums.AttackType(dec[2]),
)
def _decode_attack_type(data: typing.BinaryIO, property_size: int):
return enums.AttackType.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7d939a1: ('attack_type', _decode_attack_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct54.py | 0.618089 | 0.298319 | UnknownStruct54.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 StackableBlockBehaviorData(BaseProperty):
solid_for_roll: bool = dataclasses.field(default=False)
push_impulse: float = dataclasses.field(default=1000.0)
disable_physics: bool = dataclasses.field(default=False)
replace_collision_when_deactivated: 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\x04') # 4 properties
data.write(b'\x1d\xf1\xc4\xd1') # 0x1df1c4d1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.solid_for_roll))
data.write(b'[\xb5\x9a;') # 0x5bb59a3b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.push_impulse))
data.write(b'\xe1Z\x93\xd0') # 0xe15a93d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_physics))
data.write(b'}\xba\xcfz') # 0x7dbacf7a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.replace_collision_when_deactivated))
@classmethod
def from_json(cls, data: dict):
return cls(
solid_for_roll=data['solid_for_roll'],
push_impulse=data['push_impulse'],
disable_physics=data['disable_physics'],
replace_collision_when_deactivated=data['replace_collision_when_deactivated'],
)
def to_json(self) -> dict:
return {
'solid_for_roll': self.solid_for_roll,
'push_impulse': self.push_impulse,
'disable_physics': self.disable_physics,
'replace_collision_when_deactivated': self.replace_collision_when_deactivated,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1df1c4d1, 0x5bb59a3b, 0xe15a93d0, 0x7dbacf7a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[StackableBlockBehaviorData]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(31))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return StackableBlockBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_solid_for_roll(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_push_impulse(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disable_physics(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_replace_collision_when_deactivated(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]]] = {
0x1df1c4d1: ('solid_for_roll', _decode_solid_for_roll),
0x5bb59a3b: ('push_impulse', _decode_push_impulse),
0xe15a93d0: ('disable_physics', _decode_disable_physics),
0x7dbacf7a: ('replace_collision_when_deactivated', _decode_replace_collision_when_deactivated),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/StackableBlockBehaviorData.py | 0.579876 | 0.315367 | StackableBlockBehaviorData.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 UnknownStruct118(BaseProperty):
acceleration: float = dataclasses.field(default=5.0)
deceleration: float = dataclasses.field(default=25.0)
max_speed: float = dataclasses.field(default=15.0)
unknown_0x7e1338f8: float = dataclasses.field(default=2.0)
unknown_0x3cd77ebc: float = dataclasses.field(default=0.0)
unknown_0xe79a390f: float = dataclasses.field(default=0.10000000149011612)
unknown_0x8f922c1c: float = dataclasses.field(default=5.0)
unknown_0xd4c6cc95: float = dataclasses.field(default=0.5)
unknown_0xadb1d371: float = dataclasses.field(default=0.10000000149011612)
unknown_0x89732f60: float = dataclasses.field(default=10.0)
unknown_0x3b774d55: float = dataclasses.field(default=15.0)
max_additive_change: 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\x0c') # 12 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'\x82\xdb\x0c\xbe') # 0x82db0cbe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_speed))
data.write(b'~\x138\xf8') # 0x7e1338f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7e1338f8))
data.write(b'<\xd7~\xbc') # 0x3cd77ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3cd77ebc))
data.write(b'\xe7\x9a9\x0f') # 0xe79a390f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe79a390f))
data.write(b'\x8f\x92,\x1c') # 0x8f922c1c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8f922c1c))
data.write(b'\xd4\xc6\xcc\x95') # 0xd4c6cc95
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd4c6cc95))
data.write(b'\xad\xb1\xd3q') # 0xadb1d371
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xadb1d371))
data.write(b'\x89s/`') # 0x89732f60
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x89732f60))
data.write(b';wMU') # 0x3b774d55
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3b774d55))
data.write(b'M\xe1tr') # 0x4de17472
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_additive_change))
@classmethod
def from_json(cls, data: dict):
return cls(
acceleration=data['acceleration'],
deceleration=data['deceleration'],
max_speed=data['max_speed'],
unknown_0x7e1338f8=data['unknown_0x7e1338f8'],
unknown_0x3cd77ebc=data['unknown_0x3cd77ebc'],
unknown_0xe79a390f=data['unknown_0xe79a390f'],
unknown_0x8f922c1c=data['unknown_0x8f922c1c'],
unknown_0xd4c6cc95=data['unknown_0xd4c6cc95'],
unknown_0xadb1d371=data['unknown_0xadb1d371'],
unknown_0x89732f60=data['unknown_0x89732f60'],
unknown_0x3b774d55=data['unknown_0x3b774d55'],
max_additive_change=data['max_additive_change'],
)
def to_json(self) -> dict:
return {
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'max_speed': self.max_speed,
'unknown_0x7e1338f8': self.unknown_0x7e1338f8,
'unknown_0x3cd77ebc': self.unknown_0x3cd77ebc,
'unknown_0xe79a390f': self.unknown_0xe79a390f,
'unknown_0x8f922c1c': self.unknown_0x8f922c1c,
'unknown_0xd4c6cc95': self.unknown_0xd4c6cc95,
'unknown_0xadb1d371': self.unknown_0xadb1d371,
'unknown_0x89732f60': self.unknown_0x89732f60,
'unknown_0x3b774d55': self.unknown_0x3b774d55,
'max_additive_change': self.max_additive_change,
}
_FAST_FORMAT = None
_FAST_IDS = (0x39fb7978, 0x9ec4fc10, 0x82db0cbe, 0x7e1338f8, 0x3cd77ebc, 0xe79a390f, 0x8f922c1c, 0xd4c6cc95, 0xadb1d371, 0x89732f60, 0x3b774d55, 0x4de17472)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct118]:
if property_count != 12:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
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]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct118(
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_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_max_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7e1338f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3cd77ebc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe79a390f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8f922c1c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd4c6cc95(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xadb1d371(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x89732f60(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3b774d55(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_additive_change(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),
0x82db0cbe: ('max_speed', _decode_max_speed),
0x7e1338f8: ('unknown_0x7e1338f8', _decode_unknown_0x7e1338f8),
0x3cd77ebc: ('unknown_0x3cd77ebc', _decode_unknown_0x3cd77ebc),
0xe79a390f: ('unknown_0xe79a390f', _decode_unknown_0xe79a390f),
0x8f922c1c: ('unknown_0x8f922c1c', _decode_unknown_0x8f922c1c),
0xd4c6cc95: ('unknown_0xd4c6cc95', _decode_unknown_0xd4c6cc95),
0xadb1d371: ('unknown_0xadb1d371', _decode_unknown_0xadb1d371),
0x89732f60: ('unknown_0x89732f60', _decode_unknown_0x89732f60),
0x3b774d55: ('unknown_0x3b774d55', _decode_unknown_0x3b774d55),
0x4de17472: ('max_additive_change', _decode_max_additive_change),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct118.py | 0.672654 | 0.255524 | UnknownStruct118.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 UnknownStruct204(BaseProperty):
unknown_0xdfd9aa56: int = dataclasses.field(default=1)
unknown_0xda21386f: float = dataclasses.field(default=2.0)
unknown_0x5cb54ac1: float = dataclasses.field(default=2.0)
unknown_0x97e99964: float = dataclasses.field(default=2.0)
unknown_0x63bdd01f: int = dataclasses.field(default=0)
unknown_0x71087ff1: int = dataclasses.field(default=3)
unknown_0xc9b41894: int = dataclasses.field(default=6)
unknown_0x004297b4: bool = dataclasses.field(default=False)
unknown_0xa055a56f: 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\t') # 9 properties
data.write(b'\xdf\xd9\xaaV') # 0xdfd9aa56
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xdfd9aa56))
data.write(b'\xda!8o') # 0xda21386f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xda21386f))
data.write(b'\\\xb5J\xc1') # 0x5cb54ac1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5cb54ac1))
data.write(b'\x97\xe9\x99d') # 0x97e99964
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x97e99964))
data.write(b'c\xbd\xd0\x1f') # 0x63bdd01f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x63bdd01f))
data.write(b'q\x08\x7f\xf1') # 0x71087ff1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x71087ff1))
data.write(b'\xc9\xb4\x18\x94') # 0xc9b41894
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc9b41894))
data.write(b'\x00B\x97\xb4') # 0x4297b4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x004297b4))
data.write(b'\xa0U\xa5o') # 0xa055a56f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa055a56f))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xdfd9aa56=data['unknown_0xdfd9aa56'],
unknown_0xda21386f=data['unknown_0xda21386f'],
unknown_0x5cb54ac1=data['unknown_0x5cb54ac1'],
unknown_0x97e99964=data['unknown_0x97e99964'],
unknown_0x63bdd01f=data['unknown_0x63bdd01f'],
unknown_0x71087ff1=data['unknown_0x71087ff1'],
unknown_0xc9b41894=data['unknown_0xc9b41894'],
unknown_0x004297b4=data['unknown_0x004297b4'],
unknown_0xa055a56f=data['unknown_0xa055a56f'],
)
def to_json(self) -> dict:
return {
'unknown_0xdfd9aa56': self.unknown_0xdfd9aa56,
'unknown_0xda21386f': self.unknown_0xda21386f,
'unknown_0x5cb54ac1': self.unknown_0x5cb54ac1,
'unknown_0x97e99964': self.unknown_0x97e99964,
'unknown_0x63bdd01f': self.unknown_0x63bdd01f,
'unknown_0x71087ff1': self.unknown_0x71087ff1,
'unknown_0xc9b41894': self.unknown_0xc9b41894,
'unknown_0x004297b4': self.unknown_0x004297b4,
'unknown_0xa055a56f': self.unknown_0xa055a56f,
}
_FAST_FORMAT = None
_FAST_IDS = (0xdfd9aa56, 0xda21386f, 0x5cb54ac1, 0x97e99964, 0x63bdd01f, 0x71087ff1, 0xc9b41894, 0x4297b4, 0xa055a56f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct204]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHfLHfLHlLHlLHlLH?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]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct204(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_unknown_0xdfd9aa56(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xda21386f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5cb54ac1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x97e99964(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x63bdd01f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x71087ff1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc9b41894(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x004297b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa055a56f(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]]] = {
0xdfd9aa56: ('unknown_0xdfd9aa56', _decode_unknown_0xdfd9aa56),
0xda21386f: ('unknown_0xda21386f', _decode_unknown_0xda21386f),
0x5cb54ac1: ('unknown_0x5cb54ac1', _decode_unknown_0x5cb54ac1),
0x97e99964: ('unknown_0x97e99964', _decode_unknown_0x97e99964),
0x63bdd01f: ('unknown_0x63bdd01f', _decode_unknown_0x63bdd01f),
0x71087ff1: ('unknown_0x71087ff1', _decode_unknown_0x71087ff1),
0xc9b41894: ('unknown_0xc9b41894', _decode_unknown_0xc9b41894),
0x4297b4: ('unknown_0x004297b4', _decode_unknown_0x004297b4),
0xa055a56f: ('unknown_0xa055a56f', _decode_unknown_0xa055a56f),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct204.py | 0.613584 | 0.270244 | UnknownStruct204.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 OceanBridgeStructB(BaseProperty):
sound_select: enums.SoundSelect = dataclasses.field(default=enums.SoundSelect.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\x01') # 1 properties
data.write(b'\\\xe1\xb9\x17') # 0x5ce1b917
data.write(b'\x00\x04') # size
self.sound_select.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
sound_select=enums.SoundSelect.from_json(data['sound_select']),
)
def to_json(self) -> dict:
return {
'sound_select': self.sound_select.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x5ce1b917)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OceanBridgeStructB]:
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 OceanBridgeStructB(
enums.SoundSelect(dec[2]),
)
def _decode_sound_select(data: typing.BinaryIO, property_size: int):
return enums.SoundSelect.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5ce1b917: ('sound_select', _decode_sound_select),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OceanBridgeStructB.py | 0.615666 | 0.280194 | OceanBridgeStructB.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 UnknownStruct50(BaseProperty):
dummy: 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'\xb35\xdb\x07') # 0xb335db07
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dummy))
@classmethod
def from_json(cls, data: dict):
return cls(
dummy=data['dummy'],
)
def to_json(self) -> dict:
return {
'dummy': self.dummy,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb335db07)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct50]:
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 UnknownStruct50(
dec[2],
)
def _decode_dummy(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]]] = {
0xb335db07: ('dummy', _decode_dummy),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct50.py | 0.613468 | 0.316818 | UnknownStruct50.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 UnknownStruct128(BaseProperty):
unknown_0xc5a02c2c: bool = dataclasses.field(default=True)
unknown_0x59adc680: float = dataclasses.field(default=2.0)
unknown_0x5dbba112: 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\x03') # 3 properties
data.write(b'\xc5\xa0,,') # 0xc5a02c2c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc5a02c2c))
data.write(b'Y\xad\xc6\x80') # 0x59adc680
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x59adc680))
data.write(b']\xbb\xa1\x12') # 0x5dbba112
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5dbba112))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xc5a02c2c=data['unknown_0xc5a02c2c'],
unknown_0x59adc680=data['unknown_0x59adc680'],
unknown_0x5dbba112=data['unknown_0x5dbba112'],
)
def to_json(self) -> dict:
return {
'unknown_0xc5a02c2c': self.unknown_0xc5a02c2c,
'unknown_0x59adc680': self.unknown_0x59adc680,
'unknown_0x5dbba112': self.unknown_0x5dbba112,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc5a02c2c, 0x59adc680, 0x5dbba112)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct128]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHfLHf')
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 UnknownStruct128(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown_0xc5a02c2c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x59adc680(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5dbba112(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]]] = {
0xc5a02c2c: ('unknown_0xc5a02c2c', _decode_unknown_0xc5a02c2c),
0x59adc680: ('unknown_0x59adc680', _decode_unknown_0x59adc680),
0x5dbba112: ('unknown_0x5dbba112', _decode_unknown_0x5dbba112),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct128.py | 0.62601 | 0.296708 | UnknownStruct128.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.Color import Color
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 GrabbedBehaviorData(BaseProperty):
is_barrel: bool = dataclasses.field(default=False)
grabbable_at_creation: bool = dataclasses.field(default=False)
grabbable_when_settled: bool = dataclasses.field(default=True)
mark_grabbable_immediately_on_settle: bool = dataclasses.field(default=False)
set_as_thrown_at_creation: bool = dataclasses.field(default=False)
spawn_other_player_on_explosion: bool = dataclasses.field(default=False)
explode_on_impact_with_floor: bool = dataclasses.field(default=False)
explode_on_impact_with_wall: bool = dataclasses.field(default=True)
explode_on_impact_with_actor: bool = dataclasses.field(default=False)
explode_on_impact_with_bouncy: bool = dataclasses.field(default=False)
explode_on_impact_with_character: bool = dataclasses.field(default=False)
disable_character_material_when_grabbed: bool = dataclasses.field(default=False)
apply_damage_on_impact_with_character: bool = dataclasses.field(default=True)
apply_damage_on_impact_with_held_character: bool = dataclasses.field(default=True)
apply_damage_on_impact_with_thrown_character: bool = dataclasses.field(default=True)
bounce_on_impact_with_held_character: bool = dataclasses.field(default=False)
force_drop_on_impact_with_held_character: bool = dataclasses.field(default=False)
explode_on_impact_with_held_character: bool = dataclasses.field(default=False)
explode_on_impact_with_thrown_character: bool = dataclasses.field(default=False)
explode_on_impact_with_player: bool = dataclasses.field(default=False)
explode_on_impact_when_dropped: bool = dataclasses.field(default=False)
explode_on_impact_with_actor_when_held: bool = dataclasses.field(default=False)
explode_on_impact_with_character_when_held: bool = dataclasses.field(default=False)
apply_damage_on_impact_with_player: bool = dataclasses.field(default=True)
disable_collision_actors_on_throw: bool = dataclasses.field(default=False)
delay_explode_on_stopped_moving: float = dataclasses.field(default=0.0)
delay_explode_on_impact_with_player: float = dataclasses.field(default=0.0)
explode_time_after_throw: float = dataclasses.field(default=0.0)
flash_on_explode_timer: bool = dataclasses.field(default=False)
start_flash_on_enter_force_trigger: bool = dataclasses.field(default=False)
start_flashing_time: float = dataclasses.field(default=0.0)
flash_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=0.0, b=0.0, a=0.0))
flash_incandescence: bool = dataclasses.field(default=False)
initial_flash_period: float = dataclasses.field(default=1.0)
final_flash_period: float = dataclasses.field(default=1.0)
accelerate_flash_duration: float = dataclasses.field(default=0.0)
is_indestructible: bool = dataclasses.field(default=False)
is_immovable: bool = dataclasses.field(default=True)
lock_to_player_path_when_thrown: bool = dataclasses.field(default=True)
allow_player_walkthrough: bool = dataclasses.field(default=False)
allow_ai_walkthrough: bool = dataclasses.field(default=False)
distance_from_spline: float = dataclasses.field(default=0.0)
can_explode_off_screen: bool = dataclasses.field(default=True)
start_timer_when_partially_offscreen: bool = dataclasses.field(default=False)
max_time_off_screen: float = dataclasses.field(default=0.5)
ground_impact_damp: float = dataclasses.field(default=1.0)
wall_impact_damp: float = dataclasses.field(default=1.0)
carried_object_impact_damp: float = dataclasses.field(default=1.0)
ground_friction: float = dataclasses.field(default=0.0)
min_downward_velocity_to_bounce: float = dataclasses.field(default=6.0)
bounce_factor: float = dataclasses.field(default=0.5)
max_vertical_bounce_speed: float = dataclasses.field(default=10.0)
heal_players_on_explosion: bool = dataclasses.field(default=False)
flying_effect_speed: float = dataclasses.field(default=3.0)
flying_effect_target_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
flying_health_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
explosion_health_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
health_sound_effect: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
roll_through_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
roll_through_sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
hit_by_thrown_object_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
flash_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
flash_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
flash_sound_volume: Spline = dataclasses.field(default_factory=Spline)
dk_optional_throw_velocity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
diddy_optional_throw_velocity: 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'\x00B') # 66 properties
data.write(b'z\xcbx\xbd') # 0x7acb78bd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_barrel))
data.write(b'\xdb\x0eZQ') # 0xdb0e5a51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.grabbable_at_creation))
data.write(b'KG\x01\xdd') # 0x4b4701dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.grabbable_when_settled))
data.write(b'\xf8|c\xc6') # 0xf87c63c6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.mark_grabbable_immediately_on_settle))
data.write(b'\xd3B\xbci') # 0xd342bc69
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.set_as_thrown_at_creation))
data.write(b'\xd3-\x9f\xe3') # 0xd32d9fe3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spawn_other_player_on_explosion))
data.write(b'\xd1B\xe3\xf1') # 0xd142e3f1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_floor))
data.write(b'(\xbe\xcd\xb5') # 0x28becdb5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_wall))
data.write(b'\t\xdaT\xa0') # 0x9da54a0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_actor))
data.write(b'\xf3\xf8\xebA') # 0xf3f8eb41
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_bouncy))
data.write(b'\x0eZ,\xd9') # 0xe5a2cd9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_character))
data.write(b"'k\xa3\xe0") # 0x276ba3e0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_character_material_when_grabbed))
data.write(b'\x9d\xc8\xe8\xd6') # 0x9dc8e8d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_damage_on_impact_with_character))
data.write(b'y>{\xca') # 0x793e7bca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_damage_on_impact_with_held_character))
data.write(b')\xe4\xba\xf8') # 0x29e4baf8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_damage_on_impact_with_thrown_character))
data.write(b'A\xee{\xa8') # 0x41ee7ba8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.bounce_on_impact_with_held_character))
data.write(b'\xaau%\x11') # 0xaa752511
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_drop_on_impact_with_held_character))
data.write(b'\x9d\x8a\x7ff') # 0x9d8a7f66
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_held_character))
data.write(b',;i\xb0') # 0x2c3b69b0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_thrown_character))
data.write(b'\x12/\xc9\xcc') # 0x122fc9cc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_player))
data.write(b'@\x90\x8e\xb7') # 0x40908eb7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_when_dropped))
data.write(b'\x1b\xb0\xd6\xf0') # 0x1bb0d6f0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_actor_when_held))
data.write(b'\xdb\xb8\n\xcf') # 0xdbb80acf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.explode_on_impact_with_character_when_held))
data.write(b'G\x9a\x01\xf5') # 0x479a01f5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_damage_on_impact_with_player))
data.write(b'\xceN8C') # 0xce4e3843
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_collision_actors_on_throw))
data.write(b'\xc4\xd3\xdc\xac') # 0xc4d3dcac
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_explode_on_stopped_moving))
data.write(b'\xb6\xcb\xab1') # 0xb6cbab31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_explode_on_impact_with_player))
data.write(b'Q\xca\t<') # 0x51ca093c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.explode_time_after_throw))
data.write(b'\x89\xae\xc3N') # 0x89aec34e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.flash_on_explode_timer))
data.write(b'cQ#\xe5') # 0x635123e5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_flash_on_enter_force_trigger))
data.write(b'7w\x13`') # 0x37771360
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_flashing_time))
data.write(b"'\x11-%") # 0x27112d25
data.write(b'\x00\x10') # size
self.flash_color.to_stream(data)
data.write(b'\xd3/\xce\xdd') # 0xd32fcedd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.flash_incandescence))
data.write(b'd\xb2?\xb3') # 0x64b23fb3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_flash_period))
data.write(b'\x87\x01/\x0f') # 0x87012f0f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.final_flash_period))
data.write(b'V\x01\xc4\xfd') # 0x5601c4fd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.accelerate_flash_duration))
data.write(b'\xbf\x04\x87@') # 0xbf048740
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_indestructible))
data.write(b'\xec\x12\xed\xd7') # 0xec12edd7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_immovable))
data.write(b'\x1ap\xd4\xa5') # 0x1a70d4a5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.lock_to_player_path_when_thrown))
data.write(b'\xc6\xbf\x0f\xc0') # 0xc6bf0fc0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_player_walkthrough))
data.write(b'\xef\xa0bN') # 0xefa0624e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_ai_walkthrough))
data.write(b'\x05\xcf\t\x93') # 0x5cf0993
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance_from_spline))
data.write(b'\xc3K\x1c\xfc') # 0xc34b1cfc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_explode_off_screen))
data.write(b'B\n\xa8\xb1') # 0x420aa8b1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_timer_when_partially_offscreen))
data.write(b'\x12\xd1\xf8s') # 0x12d1f873
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_time_off_screen))
data.write(b'5\x03*\xb6') # 0x35032ab6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_impact_damp))
data.write(b'\x88F\x14B') # 0x88461442
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_impact_damp))
data.write(b'\xf4\xa3\xe2\x1e') # 0xf4a3e21e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.carried_object_impact_damp))
data.write(b'"%m|') # 0x22256d7c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_friction))
data.write(b'L\\\x17\xec') # 0x4c5c17ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_downward_velocity_to_bounce))
data.write(b'\x00+\xa5m') # 0x2ba56d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_factor))
data.write(b'\x06\xb38T') # 0x6b33854
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_vertical_bounce_speed))
data.write(b'.4\xd4\xa6') # 0x2e34d4a6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.heal_players_on_explosion))
data.write(b'\xa9\x9bMl') # 0xa99b4d6c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flying_effect_speed))
data.write(b'x~\xa8\xb1') # 0x787ea8b1
data.write(b'\x00\x0c') # size
self.flying_effect_target_scale.to_stream(data)
data.write(b'\xada\xc2:') # 0xad61c23a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flying_health_effect))
data.write(b'\x99e\xb4\x81') # 0x9965b481
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.explosion_health_effect))
data.write(b'8\x9c;\xd6') # 0x389c3bd6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.health_sound_effect))
data.write(b'\x17\x91\x85\x04') # 0x17918504
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll_through_effect))
data.write(b'l\xf5\x91Z') # 0x6cf5915a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.roll_through_sound_effect))
data.write(b'W\x18N\xe6') # 0x57184ee6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hit_by_thrown_object_sound))
data.write(b'\xb5\x8bQN') # 0xb58b514e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flash_sound))
data.write(b'\x96\xc0c\xe5') # 0x96c063e5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flash_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'\xbf\nF\xc6') # 0xbf0a46c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flash_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf6\x88\xa0B') # 0xf688a042
data.write(b'\x00\x0c') # size
self.dk_optional_throw_velocity.to_stream(data)
data.write(b'a\x84\x8d\xd1') # 0x61848dd1
data.write(b'\x00\x0c') # size
self.diddy_optional_throw_velocity.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
is_barrel=data['is_barrel'],
grabbable_at_creation=data['grabbable_at_creation'],
grabbable_when_settled=data['grabbable_when_settled'],
mark_grabbable_immediately_on_settle=data['mark_grabbable_immediately_on_settle'],
set_as_thrown_at_creation=data['set_as_thrown_at_creation'],
spawn_other_player_on_explosion=data['spawn_other_player_on_explosion'],
explode_on_impact_with_floor=data['explode_on_impact_with_floor'],
explode_on_impact_with_wall=data['explode_on_impact_with_wall'],
explode_on_impact_with_actor=data['explode_on_impact_with_actor'],
explode_on_impact_with_bouncy=data['explode_on_impact_with_bouncy'],
explode_on_impact_with_character=data['explode_on_impact_with_character'],
disable_character_material_when_grabbed=data['disable_character_material_when_grabbed'],
apply_damage_on_impact_with_character=data['apply_damage_on_impact_with_character'],
apply_damage_on_impact_with_held_character=data['apply_damage_on_impact_with_held_character'],
apply_damage_on_impact_with_thrown_character=data['apply_damage_on_impact_with_thrown_character'],
bounce_on_impact_with_held_character=data['bounce_on_impact_with_held_character'],
force_drop_on_impact_with_held_character=data['force_drop_on_impact_with_held_character'],
explode_on_impact_with_held_character=data['explode_on_impact_with_held_character'],
explode_on_impact_with_thrown_character=data['explode_on_impact_with_thrown_character'],
explode_on_impact_with_player=data['explode_on_impact_with_player'],
explode_on_impact_when_dropped=data['explode_on_impact_when_dropped'],
explode_on_impact_with_actor_when_held=data['explode_on_impact_with_actor_when_held'],
explode_on_impact_with_character_when_held=data['explode_on_impact_with_character_when_held'],
apply_damage_on_impact_with_player=data['apply_damage_on_impact_with_player'],
disable_collision_actors_on_throw=data['disable_collision_actors_on_throw'],
delay_explode_on_stopped_moving=data['delay_explode_on_stopped_moving'],
delay_explode_on_impact_with_player=data['delay_explode_on_impact_with_player'],
explode_time_after_throw=data['explode_time_after_throw'],
flash_on_explode_timer=data['flash_on_explode_timer'],
start_flash_on_enter_force_trigger=data['start_flash_on_enter_force_trigger'],
start_flashing_time=data['start_flashing_time'],
flash_color=Color.from_json(data['flash_color']),
flash_incandescence=data['flash_incandescence'],
initial_flash_period=data['initial_flash_period'],
final_flash_period=data['final_flash_period'],
accelerate_flash_duration=data['accelerate_flash_duration'],
is_indestructible=data['is_indestructible'],
is_immovable=data['is_immovable'],
lock_to_player_path_when_thrown=data['lock_to_player_path_when_thrown'],
allow_player_walkthrough=data['allow_player_walkthrough'],
allow_ai_walkthrough=data['allow_ai_walkthrough'],
distance_from_spline=data['distance_from_spline'],
can_explode_off_screen=data['can_explode_off_screen'],
start_timer_when_partially_offscreen=data['start_timer_when_partially_offscreen'],
max_time_off_screen=data['max_time_off_screen'],
ground_impact_damp=data['ground_impact_damp'],
wall_impact_damp=data['wall_impact_damp'],
carried_object_impact_damp=data['carried_object_impact_damp'],
ground_friction=data['ground_friction'],
min_downward_velocity_to_bounce=data['min_downward_velocity_to_bounce'],
bounce_factor=data['bounce_factor'],
max_vertical_bounce_speed=data['max_vertical_bounce_speed'],
heal_players_on_explosion=data['heal_players_on_explosion'],
flying_effect_speed=data['flying_effect_speed'],
flying_effect_target_scale=Vector.from_json(data['flying_effect_target_scale']),
flying_health_effect=data['flying_health_effect'],
explosion_health_effect=data['explosion_health_effect'],
health_sound_effect=data['health_sound_effect'],
roll_through_effect=data['roll_through_effect'],
roll_through_sound_effect=data['roll_through_sound_effect'],
hit_by_thrown_object_sound=data['hit_by_thrown_object_sound'],
flash_sound=data['flash_sound'],
flash_sound_pitch=Spline.from_json(data['flash_sound_pitch']),
flash_sound_volume=Spline.from_json(data['flash_sound_volume']),
dk_optional_throw_velocity=Vector.from_json(data['dk_optional_throw_velocity']),
diddy_optional_throw_velocity=Vector.from_json(data['diddy_optional_throw_velocity']),
)
def to_json(self) -> dict:
return {
'is_barrel': self.is_barrel,
'grabbable_at_creation': self.grabbable_at_creation,
'grabbable_when_settled': self.grabbable_when_settled,
'mark_grabbable_immediately_on_settle': self.mark_grabbable_immediately_on_settle,
'set_as_thrown_at_creation': self.set_as_thrown_at_creation,
'spawn_other_player_on_explosion': self.spawn_other_player_on_explosion,
'explode_on_impact_with_floor': self.explode_on_impact_with_floor,
'explode_on_impact_with_wall': self.explode_on_impact_with_wall,
'explode_on_impact_with_actor': self.explode_on_impact_with_actor,
'explode_on_impact_with_bouncy': self.explode_on_impact_with_bouncy,
'explode_on_impact_with_character': self.explode_on_impact_with_character,
'disable_character_material_when_grabbed': self.disable_character_material_when_grabbed,
'apply_damage_on_impact_with_character': self.apply_damage_on_impact_with_character,
'apply_damage_on_impact_with_held_character': self.apply_damage_on_impact_with_held_character,
'apply_damage_on_impact_with_thrown_character': self.apply_damage_on_impact_with_thrown_character,
'bounce_on_impact_with_held_character': self.bounce_on_impact_with_held_character,
'force_drop_on_impact_with_held_character': self.force_drop_on_impact_with_held_character,
'explode_on_impact_with_held_character': self.explode_on_impact_with_held_character,
'explode_on_impact_with_thrown_character': self.explode_on_impact_with_thrown_character,
'explode_on_impact_with_player': self.explode_on_impact_with_player,
'explode_on_impact_when_dropped': self.explode_on_impact_when_dropped,
'explode_on_impact_with_actor_when_held': self.explode_on_impact_with_actor_when_held,
'explode_on_impact_with_character_when_held': self.explode_on_impact_with_character_when_held,
'apply_damage_on_impact_with_player': self.apply_damage_on_impact_with_player,
'disable_collision_actors_on_throw': self.disable_collision_actors_on_throw,
'delay_explode_on_stopped_moving': self.delay_explode_on_stopped_moving,
'delay_explode_on_impact_with_player': self.delay_explode_on_impact_with_player,
'explode_time_after_throw': self.explode_time_after_throw,
'flash_on_explode_timer': self.flash_on_explode_timer,
'start_flash_on_enter_force_trigger': self.start_flash_on_enter_force_trigger,
'start_flashing_time': self.start_flashing_time,
'flash_color': self.flash_color.to_json(),
'flash_incandescence': self.flash_incandescence,
'initial_flash_period': self.initial_flash_period,
'final_flash_period': self.final_flash_period,
'accelerate_flash_duration': self.accelerate_flash_duration,
'is_indestructible': self.is_indestructible,
'is_immovable': self.is_immovable,
'lock_to_player_path_when_thrown': self.lock_to_player_path_when_thrown,
'allow_player_walkthrough': self.allow_player_walkthrough,
'allow_ai_walkthrough': self.allow_ai_walkthrough,
'distance_from_spline': self.distance_from_spline,
'can_explode_off_screen': self.can_explode_off_screen,
'start_timer_when_partially_offscreen': self.start_timer_when_partially_offscreen,
'max_time_off_screen': self.max_time_off_screen,
'ground_impact_damp': self.ground_impact_damp,
'wall_impact_damp': self.wall_impact_damp,
'carried_object_impact_damp': self.carried_object_impact_damp,
'ground_friction': self.ground_friction,
'min_downward_velocity_to_bounce': self.min_downward_velocity_to_bounce,
'bounce_factor': self.bounce_factor,
'max_vertical_bounce_speed': self.max_vertical_bounce_speed,
'heal_players_on_explosion': self.heal_players_on_explosion,
'flying_effect_speed': self.flying_effect_speed,
'flying_effect_target_scale': self.flying_effect_target_scale.to_json(),
'flying_health_effect': self.flying_health_effect,
'explosion_health_effect': self.explosion_health_effect,
'health_sound_effect': self.health_sound_effect,
'roll_through_effect': self.roll_through_effect,
'roll_through_sound_effect': self.roll_through_sound_effect,
'hit_by_thrown_object_sound': self.hit_by_thrown_object_sound,
'flash_sound': self.flash_sound,
'flash_sound_pitch': self.flash_sound_pitch.to_json(),
'flash_sound_volume': self.flash_sound_volume.to_json(),
'dk_optional_throw_velocity': self.dk_optional_throw_velocity.to_json(),
'diddy_optional_throw_velocity': self.diddy_optional_throw_velocity.to_json(),
}
def _decode_is_barrel(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_grabbable_at_creation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_grabbable_when_settled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_mark_grabbable_immediately_on_settle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_set_as_thrown_at_creation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_spawn_other_player_on_explosion(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_floor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_wall(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_actor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_bouncy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_character_material_when_grabbed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_apply_damage_on_impact_with_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_apply_damage_on_impact_with_held_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_apply_damage_on_impact_with_thrown_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_bounce_on_impact_with_held_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_force_drop_on_impact_with_held_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_held_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_thrown_character(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_when_dropped(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_actor_when_held(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explode_on_impact_with_character_when_held(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_apply_damage_on_impact_with_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_collision_actors_on_throw(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delay_explode_on_stopped_moving(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_explode_on_impact_with_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_explode_time_after_throw(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flash_on_explode_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_flash_on_enter_force_trigger(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_flashing_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flash_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_flash_incandescence(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_initial_flash_period(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_final_flash_period(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_accelerate_flash_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_indestructible(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_lock_to_player_path_when_thrown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_player_walkthrough(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_ai_walkthrough(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_distance_from_spline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_can_explode_off_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_timer_when_partially_offscreen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_time_off_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_impact_damp(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_impact_damp(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_carried_object_impact_damp(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_friction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_downward_velocity_to_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_vertical_bounce_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_heal_players_on_explosion(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flying_effect_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flying_effect_target_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_flying_health_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_explosion_health_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_health_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_roll_through_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_roll_through_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_hit_by_thrown_object_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flash_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flash_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flash_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_dk_optional_throw_velocity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_diddy_optional_throw_velocity(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]]] = {
0x7acb78bd: ('is_barrel', _decode_is_barrel),
0xdb0e5a51: ('grabbable_at_creation', _decode_grabbable_at_creation),
0x4b4701dd: ('grabbable_when_settled', _decode_grabbable_when_settled),
0xf87c63c6: ('mark_grabbable_immediately_on_settle', _decode_mark_grabbable_immediately_on_settle),
0xd342bc69: ('set_as_thrown_at_creation', _decode_set_as_thrown_at_creation),
0xd32d9fe3: ('spawn_other_player_on_explosion', _decode_spawn_other_player_on_explosion),
0xd142e3f1: ('explode_on_impact_with_floor', _decode_explode_on_impact_with_floor),
0x28becdb5: ('explode_on_impact_with_wall', _decode_explode_on_impact_with_wall),
0x9da54a0: ('explode_on_impact_with_actor', _decode_explode_on_impact_with_actor),
0xf3f8eb41: ('explode_on_impact_with_bouncy', _decode_explode_on_impact_with_bouncy),
0xe5a2cd9: ('explode_on_impact_with_character', _decode_explode_on_impact_with_character),
0x276ba3e0: ('disable_character_material_when_grabbed', _decode_disable_character_material_when_grabbed),
0x9dc8e8d6: ('apply_damage_on_impact_with_character', _decode_apply_damage_on_impact_with_character),
0x793e7bca: ('apply_damage_on_impact_with_held_character', _decode_apply_damage_on_impact_with_held_character),
0x29e4baf8: ('apply_damage_on_impact_with_thrown_character', _decode_apply_damage_on_impact_with_thrown_character),
0x41ee7ba8: ('bounce_on_impact_with_held_character', _decode_bounce_on_impact_with_held_character),
0xaa752511: ('force_drop_on_impact_with_held_character', _decode_force_drop_on_impact_with_held_character),
0x9d8a7f66: ('explode_on_impact_with_held_character', _decode_explode_on_impact_with_held_character),
0x2c3b69b0: ('explode_on_impact_with_thrown_character', _decode_explode_on_impact_with_thrown_character),
0x122fc9cc: ('explode_on_impact_with_player', _decode_explode_on_impact_with_player),
0x40908eb7: ('explode_on_impact_when_dropped', _decode_explode_on_impact_when_dropped),
0x1bb0d6f0: ('explode_on_impact_with_actor_when_held', _decode_explode_on_impact_with_actor_when_held),
0xdbb80acf: ('explode_on_impact_with_character_when_held', _decode_explode_on_impact_with_character_when_held),
0x479a01f5: ('apply_damage_on_impact_with_player', _decode_apply_damage_on_impact_with_player),
0xce4e3843: ('disable_collision_actors_on_throw', _decode_disable_collision_actors_on_throw),
0xc4d3dcac: ('delay_explode_on_stopped_moving', _decode_delay_explode_on_stopped_moving),
0xb6cbab31: ('delay_explode_on_impact_with_player', _decode_delay_explode_on_impact_with_player),
0x51ca093c: ('explode_time_after_throw', _decode_explode_time_after_throw),
0x89aec34e: ('flash_on_explode_timer', _decode_flash_on_explode_timer),
0x635123e5: ('start_flash_on_enter_force_trigger', _decode_start_flash_on_enter_force_trigger),
0x37771360: ('start_flashing_time', _decode_start_flashing_time),
0x27112d25: ('flash_color', _decode_flash_color),
0xd32fcedd: ('flash_incandescence', _decode_flash_incandescence),
0x64b23fb3: ('initial_flash_period', _decode_initial_flash_period),
0x87012f0f: ('final_flash_period', _decode_final_flash_period),
0x5601c4fd: ('accelerate_flash_duration', _decode_accelerate_flash_duration),
0xbf048740: ('is_indestructible', _decode_is_indestructible),
0xec12edd7: ('is_immovable', _decode_is_immovable),
0x1a70d4a5: ('lock_to_player_path_when_thrown', _decode_lock_to_player_path_when_thrown),
0xc6bf0fc0: ('allow_player_walkthrough', _decode_allow_player_walkthrough),
0xefa0624e: ('allow_ai_walkthrough', _decode_allow_ai_walkthrough),
0x5cf0993: ('distance_from_spline', _decode_distance_from_spline),
0xc34b1cfc: ('can_explode_off_screen', _decode_can_explode_off_screen),
0x420aa8b1: ('start_timer_when_partially_offscreen', _decode_start_timer_when_partially_offscreen),
0x12d1f873: ('max_time_off_screen', _decode_max_time_off_screen),
0x35032ab6: ('ground_impact_damp', _decode_ground_impact_damp),
0x88461442: ('wall_impact_damp', _decode_wall_impact_damp),
0xf4a3e21e: ('carried_object_impact_damp', _decode_carried_object_impact_damp),
0x22256d7c: ('ground_friction', _decode_ground_friction),
0x4c5c17ec: ('min_downward_velocity_to_bounce', _decode_min_downward_velocity_to_bounce),
0x2ba56d: ('bounce_factor', _decode_bounce_factor),
0x6b33854: ('max_vertical_bounce_speed', _decode_max_vertical_bounce_speed),
0x2e34d4a6: ('heal_players_on_explosion', _decode_heal_players_on_explosion),
0xa99b4d6c: ('flying_effect_speed', _decode_flying_effect_speed),
0x787ea8b1: ('flying_effect_target_scale', _decode_flying_effect_target_scale),
0xad61c23a: ('flying_health_effect', _decode_flying_health_effect),
0x9965b481: ('explosion_health_effect', _decode_explosion_health_effect),
0x389c3bd6: ('health_sound_effect', _decode_health_sound_effect),
0x17918504: ('roll_through_effect', _decode_roll_through_effect),
0x6cf5915a: ('roll_through_sound_effect', _decode_roll_through_sound_effect),
0x57184ee6: ('hit_by_thrown_object_sound', _decode_hit_by_thrown_object_sound),
0xb58b514e: ('flash_sound', _decode_flash_sound),
0x96c063e5: ('flash_sound_pitch', _decode_flash_sound_pitch),
0xbf0a46c6: ('flash_sound_volume', _decode_flash_sound_volume),
0xf688a042: ('dk_optional_throw_velocity', _decode_dk_optional_throw_velocity),
0x61848dd1: ('diddy_optional_throw_velocity', _decode_diddy_optional_throw_velocity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GrabbedBehaviorData.py | 0.751375 | 0.24164 | GrabbedBehaviorData.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.ForestBossStructA import ForestBossStructA
from retro_data_structures.properties.dkc_returns.archetypes.ForestBossStructB import ForestBossStructB
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct94 import UnknownStruct94
@dataclasses.dataclass()
class UnknownStruct95(BaseProperty):
head_locator: str = dataclasses.field(default='')
unknown_0x97e757ed: str = dataclasses.field(default='')
scale_locator: str = dataclasses.field(default='')
render_push: float = dataclasses.field(default=1.5)
initial_offset: float = dataclasses.field(default=10.0)
reset_offset: float = dataclasses.field(default=10.0)
unknown_0x493f3dd8: float = dataclasses.field(default=1.0)
unknown_0xcb3fd764: float = dataclasses.field(default=1.0)
unknown_0x5b604872: float = dataclasses.field(default=1.0)
forest_boss_struct_a_0xca62889e: ForestBossStructA = dataclasses.field(default_factory=ForestBossStructA)
forest_boss_struct_a_0xda392607: ForestBossStructA = dataclasses.field(default_factory=ForestBossStructA)
forest_boss_struct_a_0x30059956: ForestBossStructA = dataclasses.field(default_factory=ForestBossStructA)
forest_boss_struct_a_0x81c8ca71: ForestBossStructA = dataclasses.field(default_factory=ForestBossStructA)
unknown_struct94: UnknownStruct94 = dataclasses.field(default_factory=UnknownStruct94)
forest_boss_struct_b_0xc99a740e: ForestBossStructB = dataclasses.field(default_factory=ForestBossStructB)
forest_boss_struct_b_0x663339c4: ForestBossStructB = dataclasses.field(default_factory=ForestBossStructB)
forest_boss_struct_b_0x03540282: ForestBossStructB = dataclasses.field(default_factory=ForestBossStructB)
@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'\xda\x07\\\x18') # 0xda075c18
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.head_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'\x97\xe7W\xed') # 0x97e757ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x97e757ed.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'$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'\xaaq\x962') # 0xaa719632
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push))
data.write(b'\x8eR\xebT') # 0x8e52eb54
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_offset))
data.write(b']\xcf\x95\xc3') # 0x5dcf95c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reset_offset))
data.write(b'I?=\xd8') # 0x493f3dd8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x493f3dd8))
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'\xcab\x88\x9e') # 0xca62889e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_a_0xca62889e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xda9&\x07') # 0xda392607
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_a_0xda392607.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'0\x05\x99V') # 0x30059956
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_a_0x30059956.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x81\xc8\xcaq') # 0x81c8ca71
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_a_0x81c8ca71.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd_\xfa\xd4') # 0x645ffad4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct94.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9\x9at\x0e') # 0xc99a740e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_b_0xc99a740e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f39\xc4') # 0x663339c4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_b_0x663339c4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x03T\x02\x82') # 0x3540282
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_b_0x03540282.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(
head_locator=data['head_locator'],
unknown_0x97e757ed=data['unknown_0x97e757ed'],
scale_locator=data['scale_locator'],
render_push=data['render_push'],
initial_offset=data['initial_offset'],
reset_offset=data['reset_offset'],
unknown_0x493f3dd8=data['unknown_0x493f3dd8'],
unknown_0xcb3fd764=data['unknown_0xcb3fd764'],
unknown_0x5b604872=data['unknown_0x5b604872'],
forest_boss_struct_a_0xca62889e=ForestBossStructA.from_json(data['forest_boss_struct_a_0xca62889e']),
forest_boss_struct_a_0xda392607=ForestBossStructA.from_json(data['forest_boss_struct_a_0xda392607']),
forest_boss_struct_a_0x30059956=ForestBossStructA.from_json(data['forest_boss_struct_a_0x30059956']),
forest_boss_struct_a_0x81c8ca71=ForestBossStructA.from_json(data['forest_boss_struct_a_0x81c8ca71']),
unknown_struct94=UnknownStruct94.from_json(data['unknown_struct94']),
forest_boss_struct_b_0xc99a740e=ForestBossStructB.from_json(data['forest_boss_struct_b_0xc99a740e']),
forest_boss_struct_b_0x663339c4=ForestBossStructB.from_json(data['forest_boss_struct_b_0x663339c4']),
forest_boss_struct_b_0x03540282=ForestBossStructB.from_json(data['forest_boss_struct_b_0x03540282']),
)
def to_json(self) -> dict:
return {
'head_locator': self.head_locator,
'unknown_0x97e757ed': self.unknown_0x97e757ed,
'scale_locator': self.scale_locator,
'render_push': self.render_push,
'initial_offset': self.initial_offset,
'reset_offset': self.reset_offset,
'unknown_0x493f3dd8': self.unknown_0x493f3dd8,
'unknown_0xcb3fd764': self.unknown_0xcb3fd764,
'unknown_0x5b604872': self.unknown_0x5b604872,
'forest_boss_struct_a_0xca62889e': self.forest_boss_struct_a_0xca62889e.to_json(),
'forest_boss_struct_a_0xda392607': self.forest_boss_struct_a_0xda392607.to_json(),
'forest_boss_struct_a_0x30059956': self.forest_boss_struct_a_0x30059956.to_json(),
'forest_boss_struct_a_0x81c8ca71': self.forest_boss_struct_a_0x81c8ca71.to_json(),
'unknown_struct94': self.unknown_struct94.to_json(),
'forest_boss_struct_b_0xc99a740e': self.forest_boss_struct_b_0xc99a740e.to_json(),
'forest_boss_struct_b_0x663339c4': self.forest_boss_struct_b_0x663339c4.to_json(),
'forest_boss_struct_b_0x03540282': self.forest_boss_struct_b_0x03540282.to_json(),
}
def _decode_head_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x97e757ed(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
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_render_push(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reset_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x493f3dd8(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_forest_boss_struct_a_0xca62889e(data: typing.BinaryIO, property_size: int):
return ForestBossStructA.from_stream(data, property_size)
def _decode_forest_boss_struct_a_0xda392607(data: typing.BinaryIO, property_size: int):
return ForestBossStructA.from_stream(data, property_size)
def _decode_forest_boss_struct_a_0x30059956(data: typing.BinaryIO, property_size: int):
return ForestBossStructA.from_stream(data, property_size)
def _decode_forest_boss_struct_a_0x81c8ca71(data: typing.BinaryIO, property_size: int):
return ForestBossStructA.from_stream(data, property_size)
def _decode_unknown_struct94(data: typing.BinaryIO, property_size: int):
return UnknownStruct94.from_stream(data, property_size)
def _decode_forest_boss_struct_b_0xc99a740e(data: typing.BinaryIO, property_size: int):
return ForestBossStructB.from_stream(data, property_size)
def _decode_forest_boss_struct_b_0x663339c4(data: typing.BinaryIO, property_size: int):
return ForestBossStructB.from_stream(data, property_size)
def _decode_forest_boss_struct_b_0x03540282(data: typing.BinaryIO, property_size: int):
return ForestBossStructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xda075c18: ('head_locator', _decode_head_locator),
0x97e757ed: ('unknown_0x97e757ed', _decode_unknown_0x97e757ed),
0x24426aef: ('scale_locator', _decode_scale_locator),
0xaa719632: ('render_push', _decode_render_push),
0x8e52eb54: ('initial_offset', _decode_initial_offset),
0x5dcf95c3: ('reset_offset', _decode_reset_offset),
0x493f3dd8: ('unknown_0x493f3dd8', _decode_unknown_0x493f3dd8),
0xcb3fd764: ('unknown_0xcb3fd764', _decode_unknown_0xcb3fd764),
0x5b604872: ('unknown_0x5b604872', _decode_unknown_0x5b604872),
0xca62889e: ('forest_boss_struct_a_0xca62889e', _decode_forest_boss_struct_a_0xca62889e),
0xda392607: ('forest_boss_struct_a_0xda392607', _decode_forest_boss_struct_a_0xda392607),
0x30059956: ('forest_boss_struct_a_0x30059956', _decode_forest_boss_struct_a_0x30059956),
0x81c8ca71: ('forest_boss_struct_a_0x81c8ca71', _decode_forest_boss_struct_a_0x81c8ca71),
0x645ffad4: ('unknown_struct94', _decode_unknown_struct94),
0xc99a740e: ('forest_boss_struct_b_0xc99a740e', _decode_forest_boss_struct_b_0xc99a740e),
0x663339c4: ('forest_boss_struct_b_0x663339c4', _decode_forest_boss_struct_b_0x663339c4),
0x3540282: ('forest_boss_struct_b_0x03540282', _decode_forest_boss_struct_b_0x03540282),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct95.py | 0.505615 | 0.364862 | UnknownStruct95.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 SlideBehaviorData(BaseProperty):
slope_detection_angle: float = dataclasses.field(default=20.0)
slide_detection_angle: float = dataclasses.field(default=54.0)
slide_friction: float = dataclasses.field(default=1.0)
slow_friction: 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'N}\xef~') # 0x4e7def7e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slope_detection_angle))
data.write(b'e\x91\xa3\xa9') # 0x6591a3a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_detection_angle))
data.write(b'\xc2\x8b(^') # 0xc28b285e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_friction))
data.write(b'\xce\xd6\xfc\xcf') # 0xced6fccf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slow_friction))
@classmethod
def from_json(cls, data: dict):
return cls(
slope_detection_angle=data['slope_detection_angle'],
slide_detection_angle=data['slide_detection_angle'],
slide_friction=data['slide_friction'],
slow_friction=data['slow_friction'],
)
def to_json(self) -> dict:
return {
'slope_detection_angle': self.slope_detection_angle,
'slide_detection_angle': self.slide_detection_angle,
'slide_friction': self.slide_friction,
'slow_friction': self.slow_friction,
}
_FAST_FORMAT = None
_FAST_IDS = (0x4e7def7e, 0x6591a3a9, 0xc28b285e, 0xced6fccf)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SlideBehaviorData]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
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 SlideBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_slope_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_friction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slow_friction(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]]] = {
0x4e7def7e: ('slope_detection_angle', _decode_slope_detection_angle),
0x6591a3a9: ('slide_detection_angle', _decode_slide_detection_angle),
0xc28b285e: ('slide_friction', _decode_slide_friction),
0xced6fccf: ('slow_friction', _decode_slow_friction),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SlideBehaviorData.py | 0.667364 | 0.351979 | SlideBehaviorData.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.UnknownStruct246 import UnknownStruct246
@dataclasses.dataclass()
class UnknownStruct247(BaseProperty):
unknown_struct246: UnknownStruct246 = dataclasses.field(default_factory=UnknownStruct246)
radius: float = dataclasses.field(default=1.0)
is_moving_target: bool = dataclasses.field(default=False)
unknown_0x1ede41df: bool = dataclasses.field(default=False)
unknown_0xbde22b8e: float = dataclasses.field(default=4.0)
ignoring_duration: 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\x06') # 6 properties
data.write(b'\x93\xa4\x12\xdd') # 0x93a412dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct246.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\x84\xac\x8d\xc6') # 0x84ac8dc6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_moving_target))
data.write(b'\x1e\xdeA\xdf') # 0x1ede41df
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x1ede41df))
data.write(b'\xbd\xe2+\x8e') # 0xbde22b8e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbde22b8e))
data.write(b'\xb9\x02\xb5\xa1') # 0xb902b5a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ignoring_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct246=UnknownStruct246.from_json(data['unknown_struct246']),
radius=data['radius'],
is_moving_target=data['is_moving_target'],
unknown_0x1ede41df=data['unknown_0x1ede41df'],
unknown_0xbde22b8e=data['unknown_0xbde22b8e'],
ignoring_duration=data['ignoring_duration'],
)
def to_json(self) -> dict:
return {
'unknown_struct246': self.unknown_struct246.to_json(),
'radius': self.radius,
'is_moving_target': self.is_moving_target,
'unknown_0x1ede41df': self.unknown_0x1ede41df,
'unknown_0xbde22b8e': self.unknown_0xbde22b8e,
'ignoring_duration': self.ignoring_duration,
}
def _decode_unknown_struct246(data: typing.BinaryIO, property_size: int):
return UnknownStruct246.from_stream(data, property_size)
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_moving_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x1ede41df(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbde22b8e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ignoring_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]]] = {
0x93a412dd: ('unknown_struct246', _decode_unknown_struct246),
0x78c507eb: ('radius', _decode_radius),
0x84ac8dc6: ('is_moving_target', _decode_is_moving_target),
0x1ede41df: ('unknown_0x1ede41df', _decode_unknown_0x1ede41df),
0xbde22b8e: ('unknown_0xbde22b8e', _decode_unknown_0xbde22b8e),
0xb902b5a1: ('ignoring_duration', _decode_ignoring_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct247.py | 0.662687 | 0.318445 | UnknownStruct247.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 FixedDelayRules(BaseProperty):
number_of_fixed_delays: int = dataclasses.field(default=0)
fixed_delay1: float = dataclasses.field(default=0.0)
fixed_delay2: float = dataclasses.field(default=0.0)
fixed_delay3: float = dataclasses.field(default=0.0)
fixed_delay4: float = dataclasses.field(default=0.0)
fixed_delay5: 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\x06') # 6 properties
data.write(b'\x1f\x07\xfcI') # 0x1f07fc49
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_fixed_delays))
data.write(b'\xf5Au\xc5') # 0xf54175c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_delay1))
data.write(b's\xd5\x07k') # 0x73d5076b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_delay2))
data.write(b'\xb8\x89\xd4\xce') # 0xb889d4ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_delay3))
data.write(b'\xa5\x8c\xe4v') # 0xa58ce476
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_delay4))
data.write(b'n\xd07\xd3') # 0x6ed037d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fixed_delay5))
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_fixed_delays=data['number_of_fixed_delays'],
fixed_delay1=data['fixed_delay1'],
fixed_delay2=data['fixed_delay2'],
fixed_delay3=data['fixed_delay3'],
fixed_delay4=data['fixed_delay4'],
fixed_delay5=data['fixed_delay5'],
)
def to_json(self) -> dict:
return {
'number_of_fixed_delays': self.number_of_fixed_delays,
'fixed_delay1': self.fixed_delay1,
'fixed_delay2': self.fixed_delay2,
'fixed_delay3': self.fixed_delay3,
'fixed_delay4': self.fixed_delay4,
'fixed_delay5': self.fixed_delay5,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1f07fc49, 0xf54175c5, 0x73d5076b, 0xb889d4ce, 0xa58ce476, 0x6ed037d3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FixedDelayRules]:
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 FixedDelayRules(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_number_of_fixed_delays(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fixed_delay1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fixed_delay2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fixed_delay3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fixed_delay4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fixed_delay5(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]]] = {
0x1f07fc49: ('number_of_fixed_delays', _decode_number_of_fixed_delays),
0xf54175c5: ('fixed_delay1', _decode_fixed_delay1),
0x73d5076b: ('fixed_delay2', _decode_fixed_delay2),
0xb889d4ce: ('fixed_delay3', _decode_fixed_delay3),
0xa58ce476: ('fixed_delay4', _decode_fixed_delay4),
0x6ed037d3: ('fixed_delay5', _decode_fixed_delay5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FixedDelayRules.py | 0.621196 | 0.28138 | FixedDelayRules.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 UnknownStruct12(BaseProperty):
delay_time: float = dataclasses.field(default=0.0)
depth: float = dataclasses.field(default=0.0)
rate: float = dataclasses.field(default=0.0)
feedback: 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\x04') # 4 properties
data.write(b'\x8e\x16\xe0\x12') # 0x8e16e012
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_time))
data.write(b'\xc2\x87\xb5\xaf') # 0xc287b5af
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.depth))
data.write(b'\x16\x8a\xe1\xdd') # 0x168ae1dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rate))
data.write(b'\x1d\xa3{\r') # 0x1da37b0d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.feedback))
@classmethod
def from_json(cls, data: dict):
return cls(
delay_time=data['delay_time'],
depth=data['depth'],
rate=data['rate'],
feedback=data['feedback'],
)
def to_json(self) -> dict:
return {
'delay_time': self.delay_time,
'depth': self.depth,
'rate': self.rate,
'feedback': self.feedback,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8e16e012, 0xc287b5af, 0x168ae1dd, 0x1da37b0d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct12]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
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 UnknownStruct12(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_depth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_feedback(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]]] = {
0x8e16e012: ('delay_time', _decode_delay_time),
0xc287b5af: ('depth', _decode_depth),
0x168ae1dd: ('rate', _decode_rate),
0x1da37b0d: ('feedback', _decode_feedback),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct12.py | 0.640186 | 0.326097 | UnknownStruct12.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 KongSwingData(BaseProperty):
rope_grab_distance: float = dataclasses.field(default=10.0)
minimum_swing_time: float = dataclasses.field(default=0.10000000149011612)
swing_max_speed: float = dataclasses.field(default=30.0)
minimum_jump_height: float = dataclasses.field(default=1.0)
maximum_jump_height: float = dataclasses.field(default=3.0)
jump_tap_time: float = dataclasses.field(default=0.10000000149011612)
swing_acceleration: float = dataclasses.field(default=7.0)
swing_acceleration_multiplier_based_on_rope_radius: float = dataclasses.field(default=3.0)
vertical_release_factor: float = dataclasses.field(default=0.5)
angle_dampen_factor: float = dataclasses.field(default=3.0)
gravity: float = dataclasses.field(default=10.0)
gravity_dampen_factor: float = dataclasses.field(default=1.100000023841858)
climb_up_max_speed: float = dataclasses.field(default=4.0)
climb_up_acceleration: float = dataclasses.field(default=20.0)
climb_down_max_speed: float = dataclasses.field(default=4.0)
climb_down_acceleration: float = dataclasses.field(default=20.0)
climb_dampen_factor: float = dataclasses.field(default=4.0)
climb_analog_degrees_from_vertical: float = dataclasses.field(default=0.0)
grab_boost: float = dataclasses.field(default=2.0)
time_between_grabs: float = dataclasses.field(default=0.20000000298023224)
time_to_disable_on_scripted_release: float = dataclasses.field(default=1.0)
stall_angle_threshold: float = dataclasses.field(default=5.0)
auto_swing_release_velocity_x: float = dataclasses.field(default=6.0)
auto_swing_jump_velocity_x: float = dataclasses.field(default=9.0)
auto_swing_jump_vertical_velocity: 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\x19') # 25 properties
data.write(b'M\x0eL ') # 0x4d0e4c20
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rope_grab_distance))
data.write(b'\xeaT\xc4N') # 0xea54c44e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_swing_time))
data.write(b'r]=u') # 0x725d3d75
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_max_speed))
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'x*\x03\x10') # 0x782a0310
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_tap_time))
data.write(b'mzR\t') # 0x6d7a5209
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_acceleration))
data.write(b'\xce\xfb\xfee') # 0xcefbfe65
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_acceleration_multiplier_based_on_rope_radius))
data.write(b'?I\xe9\x87') # 0x3f49e987
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vertical_release_factor))
data.write(b':Z\xb3\x98') # 0x3a5ab398
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angle_dampen_factor))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\x1au\x844') # 0x1a758434
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity_dampen_factor))
data.write(b'\x04m\xd3\x8f') # 0x46dd38f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_up_max_speed))
data.write(b'A\xfd\xbb\x9a') # 0x41fdbb9a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_up_acceleration))
data.write(b'\xa8l\x03\x1f') # 0xa86c031f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_down_max_speed))
data.write(b'\xb7O\xb1\x8c') # 0xb74fb18c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_down_acceleration))
data.write(b'\xdf\xfa\xba>') # 0xdffaba3e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_dampen_factor))
data.write(b'\xda]g\xb1') # 0xda5d67b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.climb_analog_degrees_from_vertical))
data.write(b'9=\x1aN') # 0x393d1a4e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grab_boost))
data.write(b'\xd3,\xcf\x88') # 0xd32ccf88
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_between_grabs))
data.write(b'"\xc5\x7fd') # 0x22c57f64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_to_disable_on_scripted_release))
data.write(b'\xde\x81k\xd4') # 0xde816bd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stall_angle_threshold))
data.write(b'4\xbcsk') # 0x34bc736b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.auto_swing_release_velocity_x))
data.write(b'\xfc\xa1\xb4\xfa') # 0xfca1b4fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.auto_swing_jump_velocity_x))
data.write(b'\xb8?\xec\x12') # 0xb83fec12
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.auto_swing_jump_vertical_velocity))
@classmethod
def from_json(cls, data: dict):
return cls(
rope_grab_distance=data['rope_grab_distance'],
minimum_swing_time=data['minimum_swing_time'],
swing_max_speed=data['swing_max_speed'],
minimum_jump_height=data['minimum_jump_height'],
maximum_jump_height=data['maximum_jump_height'],
jump_tap_time=data['jump_tap_time'],
swing_acceleration=data['swing_acceleration'],
swing_acceleration_multiplier_based_on_rope_radius=data['swing_acceleration_multiplier_based_on_rope_radius'],
vertical_release_factor=data['vertical_release_factor'],
angle_dampen_factor=data['angle_dampen_factor'],
gravity=data['gravity'],
gravity_dampen_factor=data['gravity_dampen_factor'],
climb_up_max_speed=data['climb_up_max_speed'],
climb_up_acceleration=data['climb_up_acceleration'],
climb_down_max_speed=data['climb_down_max_speed'],
climb_down_acceleration=data['climb_down_acceleration'],
climb_dampen_factor=data['climb_dampen_factor'],
climb_analog_degrees_from_vertical=data['climb_analog_degrees_from_vertical'],
grab_boost=data['grab_boost'],
time_between_grabs=data['time_between_grabs'],
time_to_disable_on_scripted_release=data['time_to_disable_on_scripted_release'],
stall_angle_threshold=data['stall_angle_threshold'],
auto_swing_release_velocity_x=data['auto_swing_release_velocity_x'],
auto_swing_jump_velocity_x=data['auto_swing_jump_velocity_x'],
auto_swing_jump_vertical_velocity=data['auto_swing_jump_vertical_velocity'],
)
def to_json(self) -> dict:
return {
'rope_grab_distance': self.rope_grab_distance,
'minimum_swing_time': self.minimum_swing_time,
'swing_max_speed': self.swing_max_speed,
'minimum_jump_height': self.minimum_jump_height,
'maximum_jump_height': self.maximum_jump_height,
'jump_tap_time': self.jump_tap_time,
'swing_acceleration': self.swing_acceleration,
'swing_acceleration_multiplier_based_on_rope_radius': self.swing_acceleration_multiplier_based_on_rope_radius,
'vertical_release_factor': self.vertical_release_factor,
'angle_dampen_factor': self.angle_dampen_factor,
'gravity': self.gravity,
'gravity_dampen_factor': self.gravity_dampen_factor,
'climb_up_max_speed': self.climb_up_max_speed,
'climb_up_acceleration': self.climb_up_acceleration,
'climb_down_max_speed': self.climb_down_max_speed,
'climb_down_acceleration': self.climb_down_acceleration,
'climb_dampen_factor': self.climb_dampen_factor,
'climb_analog_degrees_from_vertical': self.climb_analog_degrees_from_vertical,
'grab_boost': self.grab_boost,
'time_between_grabs': self.time_between_grabs,
'time_to_disable_on_scripted_release': self.time_to_disable_on_scripted_release,
'stall_angle_threshold': self.stall_angle_threshold,
'auto_swing_release_velocity_x': self.auto_swing_release_velocity_x,
'auto_swing_jump_velocity_x': self.auto_swing_jump_velocity_x,
'auto_swing_jump_vertical_velocity': self.auto_swing_jump_vertical_velocity,
}
_FAST_FORMAT = None
_FAST_IDS = (0x4d0e4c20, 0xea54c44e, 0x725d3d75, 0x797aa551, 0x386d9ad7, 0x782a0310, 0x6d7a5209, 0xcefbfe65, 0x3f49e987, 0x3a5ab398, 0x2f2ae3e5, 0x1a758434, 0x46dd38f, 0x41fdbb9a, 0xa86c031f, 0xb74fb18c, 0xdffaba3e, 0xda5d67b1, 0x393d1a4e, 0xd32ccf88, 0x22c57f64, 0xde816bd4, 0x34bc736b, 0xfca1b4fa, 0xb83fec12)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[KongSwingData]:
if property_count != 25:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(250))
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], dec[54], dec[57], dec[60], dec[63], dec[66], dec[69], dec[72]) != _FAST_IDS:
data.seek(before)
return None
return KongSwingData(
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],
dec[47],
dec[50],
dec[53],
dec[56],
dec[59],
dec[62],
dec[65],
dec[68],
dec[71],
dec[74],
)
def _decode_rope_grab_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_swing_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_max_speed(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_jump_tap_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_acceleration_multiplier_based_on_rope_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vertical_release_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_angle_dampen_factor(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_gravity_dampen_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_up_max_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_up_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_down_max_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_down_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_dampen_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_climb_analog_degrees_from_vertical(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grab_boost(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_between_grabs(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_to_disable_on_scripted_release(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stall_angle_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_swing_release_velocity_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_swing_jump_velocity_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_swing_jump_vertical_velocity(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]]] = {
0x4d0e4c20: ('rope_grab_distance', _decode_rope_grab_distance),
0xea54c44e: ('minimum_swing_time', _decode_minimum_swing_time),
0x725d3d75: ('swing_max_speed', _decode_swing_max_speed),
0x797aa551: ('minimum_jump_height', _decode_minimum_jump_height),
0x386d9ad7: ('maximum_jump_height', _decode_maximum_jump_height),
0x782a0310: ('jump_tap_time', _decode_jump_tap_time),
0x6d7a5209: ('swing_acceleration', _decode_swing_acceleration),
0xcefbfe65: ('swing_acceleration_multiplier_based_on_rope_radius', _decode_swing_acceleration_multiplier_based_on_rope_radius),
0x3f49e987: ('vertical_release_factor', _decode_vertical_release_factor),
0x3a5ab398: ('angle_dampen_factor', _decode_angle_dampen_factor),
0x2f2ae3e5: ('gravity', _decode_gravity),
0x1a758434: ('gravity_dampen_factor', _decode_gravity_dampen_factor),
0x46dd38f: ('climb_up_max_speed', _decode_climb_up_max_speed),
0x41fdbb9a: ('climb_up_acceleration', _decode_climb_up_acceleration),
0xa86c031f: ('climb_down_max_speed', _decode_climb_down_max_speed),
0xb74fb18c: ('climb_down_acceleration', _decode_climb_down_acceleration),
0xdffaba3e: ('climb_dampen_factor', _decode_climb_dampen_factor),
0xda5d67b1: ('climb_analog_degrees_from_vertical', _decode_climb_analog_degrees_from_vertical),
0x393d1a4e: ('grab_boost', _decode_grab_boost),
0xd32ccf88: ('time_between_grabs', _decode_time_between_grabs),
0x22c57f64: ('time_to_disable_on_scripted_release', _decode_time_to_disable_on_scripted_release),
0xde816bd4: ('stall_angle_threshold', _decode_stall_angle_threshold),
0x34bc736b: ('auto_swing_release_velocity_x', _decode_auto_swing_release_velocity_x),
0xfca1b4fa: ('auto_swing_jump_velocity_x', _decode_auto_swing_jump_velocity_x),
0xb83fec12: ('auto_swing_jump_vertical_velocity', _decode_auto_swing_jump_vertical_velocity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongSwingData.py | 0.654453 | 0.292627 | KongSwingData.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 UnknownStruct283(BaseProperty):
unknown_0x968337ab: int = dataclasses.field(default=1)
unknown_0x8308e359: int = dataclasses.field(default=3)
@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'\x96\x837\xab') # 0x968337ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x968337ab))
data.write(b'\x83\x08\xe3Y') # 0x8308e359
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8308e359))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x968337ab=data['unknown_0x968337ab'],
unknown_0x8308e359=data['unknown_0x8308e359'],
)
def to_json(self) -> dict:
return {
'unknown_0x968337ab': self.unknown_0x968337ab,
'unknown_0x8308e359': self.unknown_0x8308e359,
}
_FAST_FORMAT = None
_FAST_IDS = (0x968337ab, 0x8308e359)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct283]:
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 UnknownStruct283(
dec[2],
dec[5],
)
def _decode_unknown_0x968337ab(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x8308e359(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]]] = {
0x968337ab: ('unknown_0x968337ab', _decode_unknown_0x968337ab),
0x8308e359: ('unknown_0x8308e359', _decode_unknown_0x8308e359),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct283.py | 0.620507 | 0.307261 | UnknownStruct283.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 UnknownStruct109(BaseProperty):
close_distance: float = dataclasses.field(default=0.0)
far_distance: 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\x02') # 2 properties
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'\xad[8\x94') # 0xad5b3894
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_distance))
@classmethod
def from_json(cls, data: dict):
return cls(
close_distance=data['close_distance'],
far_distance=data['far_distance'],
)
def to_json(self) -> dict:
return {
'close_distance': self.close_distance,
'far_distance': self.far_distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb5d2e300, 0xad5b3894)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct109]:
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 UnknownStruct109(
dec[2],
dec[5],
)
def _decode_close_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_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]]] = {
0xb5d2e300: ('close_distance', _decode_close_distance),
0xad5b3894: ('far_distance', _decode_far_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct109.py | 0.702938 | 0.37359 | UnknownStruct109.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.SpindlePositionInterpolant import SpindlePositionInterpolant
@dataclasses.dataclass()
class SpindlePosition(BaseProperty):
flags_spindle_position: int = dataclasses.field(default=320) # Flagset
angular_speed: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
linear_speed: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
motion_radius: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
radial_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
desired_angular_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
min_angular_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
max_angular_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
z_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
angular_constraint: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
angular_dampening: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
desired_angular_speed: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
constraint_flip_angle: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
@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'\xb8\xa6A:') # 0xb8a6413a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_spindle_position))
data.write(b'\xa0\xfb\x99\x86') # 0xa0fb9986
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.angular_speed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\x07\x95\x83') # 0x58079583
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.linear_speed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4L\x10\x03') # 0xe44c1003
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_radius.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'9\x93i6') # 0x39936936
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.radial_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-\x8c8\xb0') # 0x2d8c38b0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.desired_angular_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d*a\x88') # 0x1d2a6188
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.min_angular_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xcc\x9fj') # 0x91cc9f6a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.max_angular_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x90R\x89\xac') # 0x905289ac
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5\xf6\x84\x9d') # 0xf5f6849d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.angular_constraint.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{f\xa7\xb4') # 0x7b66a7b4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.angular_dampening.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h\x92l\xcd') # 0x68926ccd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.desired_angular_speed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1X\xfd;') # 0x3158fd3b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.constraint_flip_angle.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(
flags_spindle_position=data['flags_spindle_position'],
angular_speed=SpindlePositionInterpolant.from_json(data['angular_speed']),
linear_speed=SpindlePositionInterpolant.from_json(data['linear_speed']),
motion_radius=SpindlePositionInterpolant.from_json(data['motion_radius']),
radial_offset=SpindlePositionInterpolant.from_json(data['radial_offset']),
desired_angular_offset=SpindlePositionInterpolant.from_json(data['desired_angular_offset']),
min_angular_offset=SpindlePositionInterpolant.from_json(data['min_angular_offset']),
max_angular_offset=SpindlePositionInterpolant.from_json(data['max_angular_offset']),
z_offset=SpindlePositionInterpolant.from_json(data['z_offset']),
angular_constraint=SpindlePositionInterpolant.from_json(data['angular_constraint']),
angular_dampening=SpindlePositionInterpolant.from_json(data['angular_dampening']),
desired_angular_speed=SpindlePositionInterpolant.from_json(data['desired_angular_speed']),
constraint_flip_angle=SpindlePositionInterpolant.from_json(data['constraint_flip_angle']),
)
def to_json(self) -> dict:
return {
'flags_spindle_position': self.flags_spindle_position,
'angular_speed': self.angular_speed.to_json(),
'linear_speed': self.linear_speed.to_json(),
'motion_radius': self.motion_radius.to_json(),
'radial_offset': self.radial_offset.to_json(),
'desired_angular_offset': self.desired_angular_offset.to_json(),
'min_angular_offset': self.min_angular_offset.to_json(),
'max_angular_offset': self.max_angular_offset.to_json(),
'z_offset': self.z_offset.to_json(),
'angular_constraint': self.angular_constraint.to_json(),
'angular_dampening': self.angular_dampening.to_json(),
'desired_angular_speed': self.desired_angular_speed.to_json(),
'constraint_flip_angle': self.constraint_flip_angle.to_json(),
}
def _decode_flags_spindle_position(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_angular_speed(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_linear_speed(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_motion_radius(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_radial_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_desired_angular_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_min_angular_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_max_angular_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_z_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_angular_constraint(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_angular_dampening(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_desired_angular_speed(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_constraint_flip_angle(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb8a6413a: ('flags_spindle_position', _decode_flags_spindle_position),
0xa0fb9986: ('angular_speed', _decode_angular_speed),
0x58079583: ('linear_speed', _decode_linear_speed),
0xe44c1003: ('motion_radius', _decode_motion_radius),
0x39936936: ('radial_offset', _decode_radial_offset),
0x2d8c38b0: ('desired_angular_offset', _decode_desired_angular_offset),
0x1d2a6188: ('min_angular_offset', _decode_min_angular_offset),
0x91cc9f6a: ('max_angular_offset', _decode_max_angular_offset),
0x905289ac: ('z_offset', _decode_z_offset),
0xf5f6849d: ('angular_constraint', _decode_angular_constraint),
0x7b66a7b4: ('angular_dampening', _decode_angular_dampening),
0x68926ccd: ('desired_angular_speed', _decode_desired_angular_speed),
0x3158fd3b: ('constraint_flip_angle', _decode_constraint_flip_angle),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SpindlePosition.py | 0.506347 | 0.358297 | SpindlePosition.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.UnknownStruct285 import UnknownStruct285
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct286 import UnknownStruct286
@dataclasses.dataclass()
class VolcanoBossBodyPartStructB(BaseProperty):
unknown_struct285: UnknownStruct285 = dataclasses.field(default_factory=UnknownStruct285)
unknown_struct286: UnknownStruct286 = dataclasses.field(default_factory=UnknownStruct286)
@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'\xcd\x85\xb2\x9d') # 0xcd85b29d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct285.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'P\x18kj') # 0x50186b6a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct286.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_struct285=UnknownStruct285.from_json(data['unknown_struct285']),
unknown_struct286=UnknownStruct286.from_json(data['unknown_struct286']),
)
def to_json(self) -> dict:
return {
'unknown_struct285': self.unknown_struct285.to_json(),
'unknown_struct286': self.unknown_struct286.to_json(),
}
def _decode_unknown_struct285(data: typing.BinaryIO, property_size: int):
return UnknownStruct285.from_stream(data, property_size)
def _decode_unknown_struct286(data: typing.BinaryIO, property_size: int):
return UnknownStruct286.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xcd85b29d: ('unknown_struct285', _decode_unknown_struct285),
0x50186b6a: ('unknown_struct286', _decode_unknown_struct286),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VolcanoBossBodyPartStructB.py | 0.619471 | 0.317069 | VolcanoBossBodyPartStructB.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 UnknownStruct232(BaseProperty):
unknown_0x4cd75db8: float = dataclasses.field(default=3.0)
unknown_0xefee802b: float = dataclasses.field(default=2.0)
unknown_0x50ad6480: 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\x03') # 3 properties
data.write(b'L\xd7]\xb8') # 0x4cd75db8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4cd75db8))
data.write(b'\xef\xee\x80+') # 0xefee802b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xefee802b))
data.write(b'P\xadd\x80') # 0x50ad6480
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x50ad6480.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(
unknown_0x4cd75db8=data['unknown_0x4cd75db8'],
unknown_0xefee802b=data['unknown_0xefee802b'],
unknown_0x50ad6480=data['unknown_0x50ad6480'],
)
def to_json(self) -> dict:
return {
'unknown_0x4cd75db8': self.unknown_0x4cd75db8,
'unknown_0xefee802b': self.unknown_0xefee802b,
'unknown_0x50ad6480': self.unknown_0x50ad6480,
}
def _decode_unknown_0x4cd75db8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xefee802b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x50ad6480(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]]] = {
0x4cd75db8: ('unknown_0x4cd75db8', _decode_unknown_0x4cd75db8),
0xefee802b: ('unknown_0xefee802b', _decode_unknown_0xefee802b),
0x50ad6480: ('unknown_0x50ad6480', _decode_unknown_0x50ad6480),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct232.py | 0.601594 | 0.279783 | UnknownStruct232.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 UnknownStruct256(BaseProperty):
enable_head: bool = dataclasses.field(default=True)
enable_spikes: bool = dataclasses.field(default=True)
enable_above_spikes: bool = dataclasses.field(default=True)
enable_left_leg: bool = dataclasses.field(default=True)
enable_left_foot: bool = dataclasses.field(default=True)
enable_right_leg: bool = dataclasses.field(default=True)
enable_right_foot: bool = dataclasses.field(default=True)
unknown_0x2d88c50f: bool = dataclasses.field(default=True)
unknown_0x0703bf8f: bool = dataclasses.field(default=False)
unknown_0x2e0e6790: 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\n') # 10 properties
data.write(b"\x81\x02\xb8'") # 0x8102b827
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_head))
data.write(b'\xed\x93h\x00') # 0xed936800
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_spikes))
data.write(b'\xa1\x8e\xd7\xde') # 0xa18ed7de
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_above_spikes))
data.write(b'\\O\xb1K') # 0x5c4fb14b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_left_leg))
data.write(b'JR\xd2\r') # 0x4a52d20d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_left_foot))
data.write(b'\xbf1\x1dF') # 0xbf311d46
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_right_leg))
data.write(b'4\x00\xd0\x1c') # 0x3400d01c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_right_foot))
data.write(b'-\x88\xc5\x0f') # 0x2d88c50f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2d88c50f))
data.write(b'\x07\x03\xbf\x8f') # 0x703bf8f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0703bf8f))
data.write(b'.\x0eg\x90') # 0x2e0e6790
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2e0e6790))
@classmethod
def from_json(cls, data: dict):
return cls(
enable_head=data['enable_head'],
enable_spikes=data['enable_spikes'],
enable_above_spikes=data['enable_above_spikes'],
enable_left_leg=data['enable_left_leg'],
enable_left_foot=data['enable_left_foot'],
enable_right_leg=data['enable_right_leg'],
enable_right_foot=data['enable_right_foot'],
unknown_0x2d88c50f=data['unknown_0x2d88c50f'],
unknown_0x0703bf8f=data['unknown_0x0703bf8f'],
unknown_0x2e0e6790=data['unknown_0x2e0e6790'],
)
def to_json(self) -> dict:
return {
'enable_head': self.enable_head,
'enable_spikes': self.enable_spikes,
'enable_above_spikes': self.enable_above_spikes,
'enable_left_leg': self.enable_left_leg,
'enable_left_foot': self.enable_left_foot,
'enable_right_leg': self.enable_right_leg,
'enable_right_foot': self.enable_right_foot,
'unknown_0x2d88c50f': self.unknown_0x2d88c50f,
'unknown_0x0703bf8f': self.unknown_0x0703bf8f,
'unknown_0x2e0e6790': self.unknown_0x2e0e6790,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8102b827, 0xed936800, 0xa18ed7de, 0x5c4fb14b, 0x4a52d20d, 0xbf311d46, 0x3400d01c, 0x2d88c50f, 0x703bf8f, 0x2e0e6790)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct256]:
if property_count != 10:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
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 UnknownStruct256(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
)
def _decode_enable_head(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_spikes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_above_spikes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_left_leg(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_left_foot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_right_leg(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_right_foot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2d88c50f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x0703bf8f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2e0e6790(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]]] = {
0x8102b827: ('enable_head', _decode_enable_head),
0xed936800: ('enable_spikes', _decode_enable_spikes),
0xa18ed7de: ('enable_above_spikes', _decode_enable_above_spikes),
0x5c4fb14b: ('enable_left_leg', _decode_enable_left_leg),
0x4a52d20d: ('enable_left_foot', _decode_enable_left_foot),
0xbf311d46: ('enable_right_leg', _decode_enable_right_leg),
0x3400d01c: ('enable_right_foot', _decode_enable_right_foot),
0x2d88c50f: ('unknown_0x2d88c50f', _decode_unknown_0x2d88c50f),
0x703bf8f: ('unknown_0x0703bf8f', _decode_unknown_0x0703bf8f),
0x2e0e6790: ('unknown_0x2e0e6790', _decode_unknown_0x2e0e6790),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct256.py | 0.643105 | 0.304934 | UnknownStruct256.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 UnknownStruct14(BaseProperty):
view_point: float = dataclasses.field(default=0.0)
unknown_0x81dc0c16: bool = dataclasses.field(default=False)
unknown_0x2257ae80: 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\x03') # 3 properties
data.write(b'\xae\xd4(\x87') # 0xaed42887
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.view_point))
data.write(b'\x81\xdc\x0c\x16') # 0x81dc0c16
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x81dc0c16))
data.write(b'"W\xae\x80') # 0x2257ae80
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2257ae80))
@classmethod
def from_json(cls, data: dict):
return cls(
view_point=data['view_point'],
unknown_0x81dc0c16=data['unknown_0x81dc0c16'],
unknown_0x2257ae80=data['unknown_0x2257ae80'],
)
def to_json(self) -> dict:
return {
'view_point': self.view_point,
'unknown_0x81dc0c16': self.unknown_0x81dc0c16,
'unknown_0x2257ae80': self.unknown_0x2257ae80,
}
_FAST_FORMAT = None
_FAST_IDS = (0xaed42887, 0x81dc0c16, 0x2257ae80)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct14]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?LHf')
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 UnknownStruct14(
dec[2],
dec[5],
dec[8],
)
def _decode_view_point(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x81dc0c16(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2257ae80(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]]] = {
0xaed42887: ('view_point', _decode_view_point),
0x81dc0c16: ('unknown_0x81dc0c16', _decode_unknown_0x81dc0c16),
0x2257ae80: ('unknown_0x2257ae80', _decode_unknown_0x2257ae80),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct14.py | 0.625438 | 0.295783 | UnknownStruct14.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 UnknownStruct195(BaseProperty):
projectile_character: 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'!\x01\x90\xc6') # 0x210190c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_character.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(
projectile_character=AnimationParameters.from_json(data['projectile_character']),
)
def to_json(self) -> dict:
return {
'projectile_character': self.projectile_character.to_json(),
}
def _decode_projectile_character(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]]] = {
0x210190c6: ('projectile_character', _decode_projectile_character),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct195.py | 0.680454 | 0.272871 | UnknownStruct195.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 UnknownStruct122(BaseProperty):
unknown_0x9aebebc8: int = dataclasses.field(default=2036438260) # Choice
unknown_0x9af3fd16: bool = dataclasses.field(default=False)
unknown_0x314c7ce4: float = dataclasses.field(default=1.0)
unknown_0x74367d95: int = dataclasses.field(default=1)
mechanoid_delta_rate: 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\x05') # 5 properties
data.write(b'\x9a\xeb\xeb\xc8') # 0x9aebebc8
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x9aebebc8))
data.write(b'\x9a\xf3\xfd\x16') # 0x9af3fd16
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x9af3fd16))
data.write(b'1L|\xe4') # 0x314c7ce4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x314c7ce4))
data.write(b't6}\x95') # 0x74367d95
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x74367d95))
data.write(b'r\x173i') # 0x72173369
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mechanoid_delta_rate))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x9aebebc8=data['unknown_0x9aebebc8'],
unknown_0x9af3fd16=data['unknown_0x9af3fd16'],
unknown_0x314c7ce4=data['unknown_0x314c7ce4'],
unknown_0x74367d95=data['unknown_0x74367d95'],
mechanoid_delta_rate=data['mechanoid_delta_rate'],
)
def to_json(self) -> dict:
return {
'unknown_0x9aebebc8': self.unknown_0x9aebebc8,
'unknown_0x9af3fd16': self.unknown_0x9af3fd16,
'unknown_0x314c7ce4': self.unknown_0x314c7ce4,
'unknown_0x74367d95': self.unknown_0x74367d95,
'mechanoid_delta_rate': self.mechanoid_delta_rate,
}
_FAST_FORMAT = None
_FAST_IDS = (0x9aebebc8, 0x9af3fd16, 0x314c7ce4, 0x74367d95, 0x72173369)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct122]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLH?LHfLHlLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(47))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct122(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_unknown_0x9aebebc8(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x9af3fd16(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x314c7ce4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x74367d95(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mechanoid_delta_rate(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]]] = {
0x9aebebc8: ('unknown_0x9aebebc8', _decode_unknown_0x9aebebc8),
0x9af3fd16: ('unknown_0x9af3fd16', _decode_unknown_0x9af3fd16),
0x314c7ce4: ('unknown_0x314c7ce4', _decode_unknown_0x314c7ce4),
0x74367d95: ('unknown_0x74367d95', _decode_unknown_0x74367d95),
0x72173369: ('mechanoid_delta_rate', _decode_mechanoid_delta_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct122.py | 0.603698 | 0.279297 | UnknownStruct122.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.PlayerOffscreenIndicatorIconData import PlayerOffscreenIndicatorIconData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerOffscreenIndicatorTextData import PlayerOffscreenIndicatorTextData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerOffscreenIndicator(BaseProperty):
offscreen_time_til_render: float = dataclasses.field(default=0.5)
offscreen_time_til_notify: float = dataclasses.field(default=5.0)
max_time_to_render: int = dataclasses.field(default=5)
max_time_to_sound_alert: int = dataclasses.field(default=1)
offscreen_timer_tick_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
offscreen_timer_alert_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
text: PlayerOffscreenIndicatorTextData = dataclasses.field(default_factory=PlayerOffscreenIndicatorTextData)
icon: PlayerOffscreenIndicatorIconData = dataclasses.field(default_factory=PlayerOffscreenIndicatorIconData)
@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'\x0c\xcf:\xdf') # 0xccf3adf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.offscreen_time_til_render))
data.write(b'F\xc5\xcbz') # 0x46c5cb7a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.offscreen_time_til_notify))
data.write(b'I\x88\xb0+') # 0x4988b02b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_time_to_render))
data.write(b'G\xa8\x81\x8b') # 0x47a8818b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_time_to_sound_alert))
data.write(b'\x17\xbf\x00\xf0') # 0x17bf00f0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.offscreen_timer_tick_sound))
data.write(b'HhT\x9d') # 0x4868549d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.offscreen_timer_alert_sound))
data.write(b'\xa5\xb2\r\x17') # 0xa5b20d17
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.text.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\xbb\x89x') # 0xe7bb8978
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.icon.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(
offscreen_time_til_render=data['offscreen_time_til_render'],
offscreen_time_til_notify=data['offscreen_time_til_notify'],
max_time_to_render=data['max_time_to_render'],
max_time_to_sound_alert=data['max_time_to_sound_alert'],
offscreen_timer_tick_sound=data['offscreen_timer_tick_sound'],
offscreen_timer_alert_sound=data['offscreen_timer_alert_sound'],
text=PlayerOffscreenIndicatorTextData.from_json(data['text']),
icon=PlayerOffscreenIndicatorIconData.from_json(data['icon']),
)
def to_json(self) -> dict:
return {
'offscreen_time_til_render': self.offscreen_time_til_render,
'offscreen_time_til_notify': self.offscreen_time_til_notify,
'max_time_to_render': self.max_time_to_render,
'max_time_to_sound_alert': self.max_time_to_sound_alert,
'offscreen_timer_tick_sound': self.offscreen_timer_tick_sound,
'offscreen_timer_alert_sound': self.offscreen_timer_alert_sound,
'text': self.text.to_json(),
'icon': self.icon.to_json(),
}
def _decode_offscreen_time_til_render(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_offscreen_time_til_notify(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_time_to_render(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_time_to_sound_alert(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_offscreen_timer_tick_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_offscreen_timer_alert_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text(data: typing.BinaryIO, property_size: int):
return PlayerOffscreenIndicatorTextData.from_stream(data, property_size)
def _decode_icon(data: typing.BinaryIO, property_size: int):
return PlayerOffscreenIndicatorIconData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xccf3adf: ('offscreen_time_til_render', _decode_offscreen_time_til_render),
0x46c5cb7a: ('offscreen_time_til_notify', _decode_offscreen_time_til_notify),
0x4988b02b: ('max_time_to_render', _decode_max_time_to_render),
0x47a8818b: ('max_time_to_sound_alert', _decode_max_time_to_sound_alert),
0x17bf00f0: ('offscreen_timer_tick_sound', _decode_offscreen_timer_tick_sound),
0x4868549d: ('offscreen_timer_alert_sound', _decode_offscreen_timer_alert_sound),
0xa5b20d17: ('text', _decode_text),
0xe7bb8978: ('icon', _decode_icon),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerOffscreenIndicator.py | 0.563378 | 0.250534 | PlayerOffscreenIndicator.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.SpindlePositionInterpolant import SpindlePositionInterpolant
@dataclasses.dataclass()
class SpindleOrientation(BaseProperty):
flags_spindle_orientation: int = dataclasses.field(default=786432)
look_at_angular_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
look_at_z_offset: SpindlePositionInterpolant = dataclasses.field(default_factory=SpindlePositionInterpolant)
@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'\x1bIb\xbf') # 0x1b4962bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_spindle_orientation))
data.write(b'`\x9c\x06\x08') # 0x609c0608
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_angular_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf6\xc8(\xc0') # 0xf6c828c0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_z_offset.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(
flags_spindle_orientation=data['flags_spindle_orientation'],
look_at_angular_offset=SpindlePositionInterpolant.from_json(data['look_at_angular_offset']),
look_at_z_offset=SpindlePositionInterpolant.from_json(data['look_at_z_offset']),
)
def to_json(self) -> dict:
return {
'flags_spindle_orientation': self.flags_spindle_orientation,
'look_at_angular_offset': self.look_at_angular_offset.to_json(),
'look_at_z_offset': self.look_at_z_offset.to_json(),
}
def _decode_flags_spindle_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_look_at_angular_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
def _decode_look_at_z_offset(data: typing.BinaryIO, property_size: int):
return SpindlePositionInterpolant.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1b4962bf: ('flags_spindle_orientation', _decode_flags_spindle_orientation),
0x609c0608: ('look_at_angular_offset', _decode_look_at_angular_offset),
0xf6c828c0: ('look_at_z_offset', _decode_look_at_z_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SpindleOrientation.py | 0.66769 | 0.327534 | SpindleOrientation.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.UnknownStruct47 import UnknownStruct47
@dataclasses.dataclass()
class UnknownStruct193(BaseProperty):
unknown_struct47_0xd6554c1a: UnknownStruct47 = dataclasses.field(default_factory=UnknownStruct47)
unknown_struct47_0xe59c4016: UnknownStruct47 = dataclasses.field(default_factory=UnknownStruct47)
unknown_struct47_0x2416759c: UnknownStruct47 = dataclasses.field(default_factory=UnknownStruct47)
@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'\xd6UL\x1a') # 0xd6554c1a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct47_0xd6554c1a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe5\x9c@\x16') # 0xe59c4016
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct47_0xe59c4016.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\x16u\x9c') # 0x2416759c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct47_0x2416759c.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_struct47_0xd6554c1a=UnknownStruct47.from_json(data['unknown_struct47_0xd6554c1a']),
unknown_struct47_0xe59c4016=UnknownStruct47.from_json(data['unknown_struct47_0xe59c4016']),
unknown_struct47_0x2416759c=UnknownStruct47.from_json(data['unknown_struct47_0x2416759c']),
)
def to_json(self) -> dict:
return {
'unknown_struct47_0xd6554c1a': self.unknown_struct47_0xd6554c1a.to_json(),
'unknown_struct47_0xe59c4016': self.unknown_struct47_0xe59c4016.to_json(),
'unknown_struct47_0x2416759c': self.unknown_struct47_0x2416759c.to_json(),
}
def _decode_unknown_struct47_0xd6554c1a(data: typing.BinaryIO, property_size: int):
return UnknownStruct47.from_stream(data, property_size)
def _decode_unknown_struct47_0xe59c4016(data: typing.BinaryIO, property_size: int):
return UnknownStruct47.from_stream(data, property_size)
def _decode_unknown_struct47_0x2416759c(data: typing.BinaryIO, property_size: int):
return UnknownStruct47.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd6554c1a: ('unknown_struct47_0xd6554c1a', _decode_unknown_struct47_0xd6554c1a),
0xe59c4016: ('unknown_struct47_0xe59c4016', _decode_unknown_struct47_0xe59c4016),
0x2416759c: ('unknown_struct47_0x2416759c', _decode_unknown_struct47_0x2416759c),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct193.py | 0.602529 | 0.267725 | UnknownStruct193.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 CreditsData(BaseProperty):
credits_time: float = dataclasses.field(default=180.0)
normal_share_lines: int = dataclasses.field(default=4)
extra_share_per_line: float = dataclasses.field(default=0.25)
penultimate_share_bonus: float = dataclasses.field(default=0.25)
pre_penultimate_delay: float = dataclasses.field(default=1.0)
post_penultimate_delay: float = dataclasses.field(default=2.0)
final_share_bonus: float = dataclasses.field(default=1.0)
text_fade_in_time: float = dataclasses.field(default=0.25)
text_fade_out_time: float = dataclasses.field(default=0.25)
image_fade_in_time: float = dataclasses.field(default=0.25)
image_fade_out_time: float = dataclasses.field(default=0.25)
unknown_struct26_0xba717f32: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0xc344a09a: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0xd834e949: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x917857a0: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x7dfaff15: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0xe60799c8: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x45511f61: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x92b39f39: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unlock_message_total_time: float = dataclasses.field(default=4.0)
unlock_message_fade_in_time: float = dataclasses.field(default=0.25)
unlock_message_fade_out_time: float = dataclasses.field(default=0.25)
unknown_struct26_0xa45e5b13: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unlock_concept_art: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unlock_music: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unlock_diorama: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unlock_message_post_delay: float = dataclasses.field(default=0.25)
@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\x1b') # 27 properties
data.write(b'\xc7\xa74\xce') # 0xc7a734ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.credits_time))
data.write(b'N\xfel\xde') # 0x4efe6cde
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.normal_share_lines))
data.write(b'zT\xcb^') # 0x7a54cb5e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.extra_share_per_line))
data.write(b'\xfc\xa1Q\\') # 0xfca1515c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.penultimate_share_bonus))
data.write(b'\xb1\x13:\x84') # 0xb1133a84
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pre_penultimate_delay))
data.write(b'_#\x0cg') # 0x5f230c67
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.post_penultimate_delay))
data.write(b'\x9a\x9a}\x1f') # 0x9a9a7d1f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.final_share_bonus))
data.write(b'\xa0\x91\xf3\x93') # 0xa091f393
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_fade_in_time))
data.write(b'\x98\x18jp') # 0x98186a70
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_fade_out_time))
data.write(b'\xc1\xb9\xee\xf1') # 0xc1b9eef1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.image_fade_in_time))
data.write(b';\xc5B\x19') # 0x3bc54219
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.image_fade_out_time))
data.write(b'\xbaq\x7f2') # 0xba717f32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xba717f32.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3D\xa0\x9a') # 0xc344a09a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xc344a09a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd84\xe9I') # 0xd834e949
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xd834e949.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91xW\xa0') # 0x917857a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x917857a0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'}\xfa\xff\x15') # 0x7dfaff15
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x7dfaff15.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6\x07\x99\xc8') # 0xe60799c8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xe60799c8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'EQ\x1fa') # 0x45511f61
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x45511f61.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x92\xb3\x9f9') # 0x92b39f39
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x92b39f39.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb5K\x9d%') # 0xb54b9d25
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unlock_message_total_time))
data.write(b'\x8f\xdc\x94\x87') # 0x8fdc9487
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unlock_message_fade_in_time))
data.write(b'\x82\xed\xf3j') # 0x82edf36a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unlock_message_fade_out_time))
data.write(b'\xa4^[\x13') # 0xa45e5b13
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xa45e5b13.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'yX\x9b\xf4') # 0x79589bf4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unlock_concept_art))
data.write(b'\n\xf7\x07\xdf') # 0xaf707df
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unlock_music))
data.write(b'\\\xe2\xa9\xa9') # 0x5ce2a9a9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unlock_diorama))
data.write(b'\x99J\xa2}') # 0x994aa27d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unlock_message_post_delay))
@classmethod
def from_json(cls, data: dict):
return cls(
credits_time=data['credits_time'],
normal_share_lines=data['normal_share_lines'],
extra_share_per_line=data['extra_share_per_line'],
penultimate_share_bonus=data['penultimate_share_bonus'],
pre_penultimate_delay=data['pre_penultimate_delay'],
post_penultimate_delay=data['post_penultimate_delay'],
final_share_bonus=data['final_share_bonus'],
text_fade_in_time=data['text_fade_in_time'],
text_fade_out_time=data['text_fade_out_time'],
image_fade_in_time=data['image_fade_in_time'],
image_fade_out_time=data['image_fade_out_time'],
unknown_struct26_0xba717f32=UnknownStruct26.from_json(data['unknown_struct26_0xba717f32']),
unknown_struct26_0xc344a09a=UnknownStruct26.from_json(data['unknown_struct26_0xc344a09a']),
unknown_struct26_0xd834e949=UnknownStruct26.from_json(data['unknown_struct26_0xd834e949']),
unknown_struct26_0x917857a0=UnknownStruct26.from_json(data['unknown_struct26_0x917857a0']),
unknown_struct26_0x7dfaff15=UnknownStruct26.from_json(data['unknown_struct26_0x7dfaff15']),
unknown_struct26_0xe60799c8=UnknownStruct26.from_json(data['unknown_struct26_0xe60799c8']),
unknown_struct26_0x45511f61=UnknownStruct26.from_json(data['unknown_struct26_0x45511f61']),
unknown_struct26_0x92b39f39=UnknownStruct26.from_json(data['unknown_struct26_0x92b39f39']),
unlock_message_total_time=data['unlock_message_total_time'],
unlock_message_fade_in_time=data['unlock_message_fade_in_time'],
unlock_message_fade_out_time=data['unlock_message_fade_out_time'],
unknown_struct26_0xa45e5b13=UnknownStruct26.from_json(data['unknown_struct26_0xa45e5b13']),
unlock_concept_art=data['unlock_concept_art'],
unlock_music=data['unlock_music'],
unlock_diorama=data['unlock_diorama'],
unlock_message_post_delay=data['unlock_message_post_delay'],
)
def to_json(self) -> dict:
return {
'credits_time': self.credits_time,
'normal_share_lines': self.normal_share_lines,
'extra_share_per_line': self.extra_share_per_line,
'penultimate_share_bonus': self.penultimate_share_bonus,
'pre_penultimate_delay': self.pre_penultimate_delay,
'post_penultimate_delay': self.post_penultimate_delay,
'final_share_bonus': self.final_share_bonus,
'text_fade_in_time': self.text_fade_in_time,
'text_fade_out_time': self.text_fade_out_time,
'image_fade_in_time': self.image_fade_in_time,
'image_fade_out_time': self.image_fade_out_time,
'unknown_struct26_0xba717f32': self.unknown_struct26_0xba717f32.to_json(),
'unknown_struct26_0xc344a09a': self.unknown_struct26_0xc344a09a.to_json(),
'unknown_struct26_0xd834e949': self.unknown_struct26_0xd834e949.to_json(),
'unknown_struct26_0x917857a0': self.unknown_struct26_0x917857a0.to_json(),
'unknown_struct26_0x7dfaff15': self.unknown_struct26_0x7dfaff15.to_json(),
'unknown_struct26_0xe60799c8': self.unknown_struct26_0xe60799c8.to_json(),
'unknown_struct26_0x45511f61': self.unknown_struct26_0x45511f61.to_json(),
'unknown_struct26_0x92b39f39': self.unknown_struct26_0x92b39f39.to_json(),
'unlock_message_total_time': self.unlock_message_total_time,
'unlock_message_fade_in_time': self.unlock_message_fade_in_time,
'unlock_message_fade_out_time': self.unlock_message_fade_out_time,
'unknown_struct26_0xa45e5b13': self.unknown_struct26_0xa45e5b13.to_json(),
'unlock_concept_art': self.unlock_concept_art,
'unlock_music': self.unlock_music,
'unlock_diorama': self.unlock_diorama,
'unlock_message_post_delay': self.unlock_message_post_delay,
}
def _decode_credits_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_normal_share_lines(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_extra_share_per_line(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_penultimate_share_bonus(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pre_penultimate_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_post_penultimate_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_final_share_bonus(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_text_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_text_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_image_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_image_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct26_0xba717f32(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0xc344a09a(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0xd834e949(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x917857a0(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x7dfaff15(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0xe60799c8(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x45511f61(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x92b39f39(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unlock_message_total_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unlock_message_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unlock_message_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct26_0xa45e5b13(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unlock_concept_art(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unlock_music(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unlock_diorama(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unlock_message_post_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]]] = {
0xc7a734ce: ('credits_time', _decode_credits_time),
0x4efe6cde: ('normal_share_lines', _decode_normal_share_lines),
0x7a54cb5e: ('extra_share_per_line', _decode_extra_share_per_line),
0xfca1515c: ('penultimate_share_bonus', _decode_penultimate_share_bonus),
0xb1133a84: ('pre_penultimate_delay', _decode_pre_penultimate_delay),
0x5f230c67: ('post_penultimate_delay', _decode_post_penultimate_delay),
0x9a9a7d1f: ('final_share_bonus', _decode_final_share_bonus),
0xa091f393: ('text_fade_in_time', _decode_text_fade_in_time),
0x98186a70: ('text_fade_out_time', _decode_text_fade_out_time),
0xc1b9eef1: ('image_fade_in_time', _decode_image_fade_in_time),
0x3bc54219: ('image_fade_out_time', _decode_image_fade_out_time),
0xba717f32: ('unknown_struct26_0xba717f32', _decode_unknown_struct26_0xba717f32),
0xc344a09a: ('unknown_struct26_0xc344a09a', _decode_unknown_struct26_0xc344a09a),
0xd834e949: ('unknown_struct26_0xd834e949', _decode_unknown_struct26_0xd834e949),
0x917857a0: ('unknown_struct26_0x917857a0', _decode_unknown_struct26_0x917857a0),
0x7dfaff15: ('unknown_struct26_0x7dfaff15', _decode_unknown_struct26_0x7dfaff15),
0xe60799c8: ('unknown_struct26_0xe60799c8', _decode_unknown_struct26_0xe60799c8),
0x45511f61: ('unknown_struct26_0x45511f61', _decode_unknown_struct26_0x45511f61),
0x92b39f39: ('unknown_struct26_0x92b39f39', _decode_unknown_struct26_0x92b39f39),
0xb54b9d25: ('unlock_message_total_time', _decode_unlock_message_total_time),
0x8fdc9487: ('unlock_message_fade_in_time', _decode_unlock_message_fade_in_time),
0x82edf36a: ('unlock_message_fade_out_time', _decode_unlock_message_fade_out_time),
0xa45e5b13: ('unknown_struct26_0xa45e5b13', _decode_unknown_struct26_0xa45e5b13),
0x79589bf4: ('unlock_concept_art', _decode_unlock_concept_art),
0xaf707df: ('unlock_music', _decode_unlock_music),
0x5ce2a9a9: ('unlock_diorama', _decode_unlock_diorama),
0x994aa27d: ('unlock_message_post_delay', _decode_unlock_message_post_delay),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CreditsData.py | 0.547827 | 0.167117 | CreditsData.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 RambiControllerData(BaseProperty):
flee_speed_percentage: float = dataclasses.field(default=50.0)
maintain_direction_time: float = dataclasses.field(default=2.0)
off_screen_turn_around_distance: float = dataclasses.field(default=3.0)
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)
@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'\x04\x9b\xfc\x1b') # 0x49bfc1b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flee_speed_percentage))
data.write(b'Df\x01n') # 0x4466016e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maintain_direction_time))
data.write(b'\x7f\xf6\xb0\x94') # 0x7ff6b094
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.off_screen_turn_around_distance))
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))
@classmethod
def from_json(cls, data: dict):
return cls(
flee_speed_percentage=data['flee_speed_percentage'],
maintain_direction_time=data['maintain_direction_time'],
off_screen_turn_around_distance=data['off_screen_turn_around_distance'],
despawn_timer=data['despawn_timer'],
despawn_distance=data['despawn_distance'],
far_despawn_distance=data['far_despawn_distance'],
)
def to_json(self) -> dict:
return {
'flee_speed_percentage': self.flee_speed_percentage,
'maintain_direction_time': self.maintain_direction_time,
'off_screen_turn_around_distance': self.off_screen_turn_around_distance,
'despawn_timer': self.despawn_timer,
'despawn_distance': self.despawn_distance,
'far_despawn_distance': self.far_despawn_distance,
}
_FAST_FORMAT = None
_FAST_IDS = (0x49bfc1b, 0x4466016e, 0x7ff6b094, 0xbc2f0b41, 0xe7655628, 0xebe02cd7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RambiControllerData]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHf')
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 RambiControllerData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_flee_speed_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maintain_direction_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_off_screen_turn_around_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x49bfc1b: ('flee_speed_percentage', _decode_flee_speed_percentage),
0x4466016e: ('maintain_direction_time', _decode_maintain_direction_time),
0x7ff6b094: ('off_screen_turn_around_distance', _decode_off_screen_turn_around_distance),
0xbc2f0b41: ('despawn_timer', _decode_despawn_timer),
0xe7655628: ('despawn_distance', _decode_despawn_distance),
0xebe02cd7: ('far_despawn_distance', _decode_far_despawn_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RambiControllerData.py | 0.661267 | 0.320489 | RambiControllerData.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.UnknownStruct148 import UnknownStruct148
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct35 import UnknownStruct35
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct149(BaseProperty):
pause_hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
options_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
puzzle_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
continue_game_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
quit_game_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct35: UnknownStruct35 = dataclasses.field(default_factory=UnknownStruct35)
quit_confirm_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
restart_confirm_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct148: UnknownStruct148 = dataclasses.field(default_factory=UnknownStruct148)
@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'@K\x98\xb2') # 0x404b98b2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.pause_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'\xf7\xcbR\xf1') # 0xf7cb52f1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.options_string))
data.write(b'\xa1qA\x02') # 0xa1714102
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.puzzle_string))
data.write(b',t\xe19') # 0x2c74e139
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'u%\xf9C') # 0x7525f943
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.continue_game_string))
data.write(b'$5h\x17') # 0x24356817
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.quit_game_string))
data.write(b'\xd8U$\xdb') # 0xd85524db
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct35.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\xb3\xaa\xc2') # 0xfdb3aac2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.quit_confirm_text))
data.write(b'+K~\xf6') # 0x2b4b7ef6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.restart_confirm_text))
data.write(b'\x98[\xfc\xd9') # 0x985bfcd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct148.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(
pause_hud_frame=data['pause_hud_frame'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
options_string=data['options_string'],
puzzle_string=data['puzzle_string'],
strg=data['strg'],
continue_game_string=data['continue_game_string'],
quit_game_string=data['quit_game_string'],
unknown_struct35=UnknownStruct35.from_json(data['unknown_struct35']),
quit_confirm_text=data['quit_confirm_text'],
restart_confirm_text=data['restart_confirm_text'],
unknown_struct148=UnknownStruct148.from_json(data['unknown_struct148']),
)
def to_json(self) -> dict:
return {
'pause_hud_frame': self.pause_hud_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'options_string': self.options_string,
'puzzle_string': self.puzzle_string,
'strg': self.strg,
'continue_game_string': self.continue_game_string,
'quit_game_string': self.quit_game_string,
'unknown_struct35': self.unknown_struct35.to_json(),
'quit_confirm_text': self.quit_confirm_text,
'restart_confirm_text': self.restart_confirm_text,
'unknown_struct148': self.unknown_struct148.to_json(),
}
def _decode_pause_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_options_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_puzzle_string(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_continue_game_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_quit_game_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct35(data: typing.BinaryIO, property_size: int):
return UnknownStruct35.from_stream(data, property_size)
def _decode_quit_confirm_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_restart_confirm_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct148(data: typing.BinaryIO, property_size: int):
return UnknownStruct148.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x404b98b2: ('pause_hud_frame', _decode_pause_hud_frame),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xf7cb52f1: ('options_string', _decode_options_string),
0xa1714102: ('puzzle_string', _decode_puzzle_string),
0x2c74e139: ('strg', _decode_strg),
0x7525f943: ('continue_game_string', _decode_continue_game_string),
0x24356817: ('quit_game_string', _decode_quit_game_string),
0xd85524db: ('unknown_struct35', _decode_unknown_struct35),
0xfdb3aac2: ('quit_confirm_text', _decode_quit_confirm_text),
0x2b4b7ef6: ('restart_confirm_text', _decode_restart_confirm_text),
0x985bfcd9: ('unknown_struct148', _decode_unknown_struct148),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct149.py | 0.513912 | 0.179387 | UnknownStruct149.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 UnknownStruct272(BaseProperty):
mode: enums.Mode = dataclasses.field(default=enums.Mode.Unknown1)
progression: 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\x02') # 2 properties
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
self.mode.to_stream(data)
data.write(b'\xef\xa9\x04\xbe') # 0xefa904be
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.progression))
@classmethod
def from_json(cls, data: dict):
return cls(
mode=enums.Mode.from_json(data['mode']),
progression=data['progression'],
)
def to_json(self) -> dict:
return {
'mode': self.mode.to_json(),
'progression': self.progression,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb8f60f9a, 0xefa904be)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct272]:
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 UnknownStruct272(
enums.Mode(dec[2]),
dec[5],
)
def _decode_mode(data: typing.BinaryIO, property_size: int):
return enums.Mode.from_stream(data)
def _decode_progression(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]]] = {
0xb8f60f9a: ('mode', _decode_mode),
0xefa904be: ('progression', _decode_progression),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct272.py | 0.642769 | 0.27896 | UnknownStruct272.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 DebrisPropertiesOrientationEnum(BaseProperty):
orientation: int = dataclasses.field(default=1990589437) # Choice
@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\xbff7') # 0xf4bf6637
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.orientation))
@classmethod
def from_json(cls, data: dict):
return cls(
orientation=data['orientation'],
)
def to_json(self) -> dict:
return {
'orientation': self.orientation,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf4bf6637)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DebrisPropertiesOrientationEnum]:
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 DebrisPropertiesOrientationEnum(
dec[2],
)
def _decode_orientation(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]]] = {
0xf4bf6637: ('orientation', _decode_orientation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DebrisPropertiesOrientationEnum.py | 0.668556 | 0.302192 | DebrisPropertiesOrientationEnum.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.CharacterGlueData import CharacterGlueData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerCrushData import PlayerCrushData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerPeriodicAdditiveAnimationData import PlayerPeriodicAdditiveAnimationData
from retro_data_structures.properties.dkc_returns.archetypes.TandemBeam import TandemBeam
from retro_data_structures.properties.dkc_returns.archetypes.TrackObjectModuleData import TrackObjectModuleData
@dataclasses.dataclass()
class UnknownStruct140(BaseProperty):
unknown: int = dataclasses.field(default=0)
periodic_additive_animation_data: PlayerPeriodicAdditiveAnimationData = dataclasses.field(default_factory=PlayerPeriodicAdditiveAnimationData)
crush_data: PlayerCrushData = dataclasses.field(default_factory=PlayerCrushData)
track_object_module_data: TrackObjectModuleData = dataclasses.field(default_factory=TrackObjectModuleData)
character_glue: CharacterGlueData = dataclasses.field(default_factory=CharacterGlueData)
tandem_beam: TandemBeam = dataclasses.field(default_factory=TandemBeam)
@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'\x94\xdd\x89y') # 0x94dd8979
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\x97]\xce\xf7') # 0x975dcef7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.periodic_additive_animation_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8a\xbb%\xc4') # 0x8abb25c4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.crush_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf4\xd3\x95\x93') # 0xf4d39593
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.track_object_module_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9d\x9c\xe3%') # 0x9d9ce325
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_glue.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'4\xa9y\xa6') # 0x34a979a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tandem_beam.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=data['unknown'],
periodic_additive_animation_data=PlayerPeriodicAdditiveAnimationData.from_json(data['periodic_additive_animation_data']),
crush_data=PlayerCrushData.from_json(data['crush_data']),
track_object_module_data=TrackObjectModuleData.from_json(data['track_object_module_data']),
character_glue=CharacterGlueData.from_json(data['character_glue']),
tandem_beam=TandemBeam.from_json(data['tandem_beam']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'periodic_additive_animation_data': self.periodic_additive_animation_data.to_json(),
'crush_data': self.crush_data.to_json(),
'track_object_module_data': self.track_object_module_data.to_json(),
'character_glue': self.character_glue.to_json(),
'tandem_beam': self.tandem_beam.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_periodic_additive_animation_data(data: typing.BinaryIO, property_size: int):
return PlayerPeriodicAdditiveAnimationData.from_stream(data, property_size)
def _decode_crush_data(data: typing.BinaryIO, property_size: int):
return PlayerCrushData.from_stream(data, property_size)
def _decode_track_object_module_data(data: typing.BinaryIO, property_size: int):
return TrackObjectModuleData.from_stream(data, property_size)
def _decode_character_glue(data: typing.BinaryIO, property_size: int):
return CharacterGlueData.from_stream(data, property_size)
def _decode_tandem_beam(data: typing.BinaryIO, property_size: int):
return TandemBeam.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x94dd8979: ('unknown', _decode_unknown),
0x975dcef7: ('periodic_additive_animation_data', _decode_periodic_additive_animation_data),
0x8abb25c4: ('crush_data', _decode_crush_data),
0xf4d39593: ('track_object_module_data', _decode_track_object_module_data),
0x9d9ce325: ('character_glue', _decode_character_glue),
0x34a979a6: ('tandem_beam', _decode_tandem_beam),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct140.py | 0.622918 | 0.315551 | UnknownStruct140.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 Vector2f(BaseProperty):
x: float = dataclasses.field(default=0.0)
y: 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\x02') # 2 properties
data.write(b'\xa1g}N') # 0xa1677d4e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.x))
data.write(b'j;\xae\xeb') # 0x6a3baeeb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.y))
@classmethod
def from_json(cls, data: dict):
return cls(
x=data['x'],
y=data['y'],
)
def to_json(self) -> dict:
return {
'x': self.x,
'y': self.y,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa1677d4e, 0x6a3baeeb)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Vector2f]:
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 Vector2f(
dec[2],
dec[5],
)
def _decode_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_y(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]]] = {
0xa1677d4e: ('x', _decode_x),
0x6a3baeeb: ('y', _decode_y),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/Vector2f.py | 0.677367 | 0.346182 | Vector2f.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.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct166(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
freelook_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
freelook_prompt_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0xe8ac748d: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0xfebbc04e: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x5eeb7f9d: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0xcbc01154: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x777cf37f: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x66b1160b: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x7f1e6dec: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
cancel_prompt_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x6b016db2: 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)
menu: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
menu_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
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\x12') # 18 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'\xf5\xcb\x9f2') # 0xf5cb9f32
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.freelook_text))
data.write(b'!\xcb-\x81') # 0x21cb2d81
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.freelook_prompt_text))
data.write(b'\xe8\xact\x8d') # 0xe8ac748d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0xe8ac748d))
data.write(b'\xfe\xbb\xc0N') # 0xfebbc04e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0xfebbc04e))
data.write(b'^\xeb\x7f\x9d') # 0x5eeb7f9d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x5eeb7f9d))
data.write(b'\xcb\xc0\x11T') # 0xcbc01154
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0xcbc01154))
data.write(b'w|\xf3\x7f') # 0x777cf37f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x777cf37f))
data.write(b'f\xb1\x16\x0b') # 0x66b1160b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x66b1160b))
data.write(b'\x7f\x1em\xec') # 0x7f1e6dec
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x7f1e6dec))
data.write(b'\xb7\x99\x06Q') # 0xb7990651
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cancel_prompt_text))
data.write(b'k\x01m\xb2') # 0x6b016db2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x6b016db2))
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'\xea\xcb\xa7U') # 0xeacba755
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.menu))
data.write(b'\xa1\x8e\xdf-') # 0xa18edf2d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.menu_core))
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'\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(
gui_frame=data['gui_frame'],
freelook_text=data['freelook_text'],
freelook_prompt_text=data['freelook_prompt_text'],
strg_0xe8ac748d=data['strg_0xe8ac748d'],
strg_0xfebbc04e=data['strg_0xfebbc04e'],
strg_0x5eeb7f9d=data['strg_0x5eeb7f9d'],
strg_0xcbc01154=data['strg_0xcbc01154'],
strg_0x777cf37f=data['strg_0x777cf37f'],
strg_0x66b1160b=data['strg_0x66b1160b'],
strg_0x7f1e6dec=data['strg_0x7f1e6dec'],
cancel_prompt_text=data['cancel_prompt_text'],
strg_0x6b016db2=data['strg_0x6b016db2'],
select=data['select'],
select_core=data['select_core'],
menu=data['menu'],
menu_core=data['menu_core'],
unknown_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'freelook_text': self.freelook_text,
'freelook_prompt_text': self.freelook_prompt_text,
'strg_0xe8ac748d': self.strg_0xe8ac748d,
'strg_0xfebbc04e': self.strg_0xfebbc04e,
'strg_0x5eeb7f9d': self.strg_0x5eeb7f9d,
'strg_0xcbc01154': self.strg_0xcbc01154,
'strg_0x777cf37f': self.strg_0x777cf37f,
'strg_0x66b1160b': self.strg_0x66b1160b,
'strg_0x7f1e6dec': self.strg_0x7f1e6dec,
'cancel_prompt_text': self.cancel_prompt_text,
'strg_0x6b016db2': self.strg_0x6b016db2,
'select': self.select,
'select_core': self.select_core,
'menu': self.menu,
'menu_core': self.menu_core,
'unknown_struct27': self.unknown_struct27.to_json(),
'text_background': self.text_background,
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_freelook_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_freelook_prompt_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0xe8ac748d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0xfebbc04e(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x5eeb7f9d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0xcbc01154(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x777cf37f(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x66b1160b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x7f1e6dec(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cancel_prompt_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x6b016db2(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_menu(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_menu_core(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_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]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0xf5cb9f32: ('freelook_text', _decode_freelook_text),
0x21cb2d81: ('freelook_prompt_text', _decode_freelook_prompt_text),
0xe8ac748d: ('strg_0xe8ac748d', _decode_strg_0xe8ac748d),
0xfebbc04e: ('strg_0xfebbc04e', _decode_strg_0xfebbc04e),
0x5eeb7f9d: ('strg_0x5eeb7f9d', _decode_strg_0x5eeb7f9d),
0xcbc01154: ('strg_0xcbc01154', _decode_strg_0xcbc01154),
0x777cf37f: ('strg_0x777cf37f', _decode_strg_0x777cf37f),
0x66b1160b: ('strg_0x66b1160b', _decode_strg_0x66b1160b),
0x7f1e6dec: ('strg_0x7f1e6dec', _decode_strg_0x7f1e6dec),
0xb7990651: ('cancel_prompt_text', _decode_cancel_prompt_text),
0x6b016db2: ('strg_0x6b016db2', _decode_strg_0x6b016db2),
0x8ed65283: ('select', _decode_select),
0xa40d410e: ('select_core', _decode_select_core),
0xeacba755: ('menu', _decode_menu),
0xa18edf2d: ('menu_core', _decode_menu_core),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct166.py | 0.512937 | 0.169715 | UnknownStruct166.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 PlayerCrushData(BaseProperty):
shove_limit: float = dataclasses.field(default=0.10000000149011612)
pinch_limit: float = dataclasses.field(default=0.5)
minimum_display_size: float = dataclasses.field(default=0.5)
failsafe_delay: float = dataclasses.field(default=4.0)
pre_breakout_buffer: float = dataclasses.field(default=0.10000000149011612)
landing_blend_time: float = dataclasses.field(default=0.05000000074505806)
can_crush_push_player: bool = dataclasses.field(default=False)
horz_revive_delay: float = dataclasses.field(default=0.5)
horz_revive_limit: float = dataclasses.field(default=0.05000000074505806)
horz_reflate_time: float = dataclasses.field(default=0.05000000074505806)
horz_knock_back_speed: float = dataclasses.field(default=12.0)
horz_hurl_height: float = dataclasses.field(default=6.0)
horz_pop_right_velocity: float = dataclasses.field(default=1.0)
horz_pop_left_velocity: float = dataclasses.field(default=1.0)
horz_pop_up_velocity: float = dataclasses.field(default=1.0)
horz_offset_right: float = dataclasses.field(default=0.20000000298023224)
horz_offset_left: float = dataclasses.field(default=0.20000000298023224)
horz_rider_offset_right: float = dataclasses.field(default=-0.15000000596046448)
horz_rider_offset_left: float = dataclasses.field(default=-0.20000000298023224)
horz_stop_player: bool = dataclasses.field(default=False)
vert_revive_delay: float = dataclasses.field(default=0.5)
vert_revive_limit: float = dataclasses.field(default=0.05000000074505806)
vert_reflate_time: float = dataclasses.field(default=0.05000000074505806)
vert_knock_back_speed: float = dataclasses.field(default=2.0)
vert_hurl_height: float = dataclasses.field(default=6.0)
vert_pop_up_velocity: float = dataclasses.field(default=2.0)
vert_pop_down_velocity: float = dataclasses.field(default=2.0)
vert_offset_up: float = dataclasses.field(default=0.5)
vert_offset_down: float = dataclasses.field(default=0.0)
vert_rider_offset_up: float = dataclasses.field(default=-0.05000000074505806)
vert_rider_offset_down: float = dataclasses.field(default=-0.5)
vert_stop_player: 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 ') # 32 properties
data.write(b'u\x89x\x9b') # 0x7589789b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shove_limit))
data.write(b'{B\xfd\xfa') # 0x7b42fdfa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pinch_limit))
data.write(b'G\xf3\xf1\x01') # 0x47f3f101
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_display_size))
data.write(b'\x90\xaa\r\x86') # 0x90aa0d86
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.failsafe_delay))
data.write(b'\xe8\xc4\xba\x9b') # 0xe8c4ba9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pre_breakout_buffer))
data.write(b'\xf5K#\x92') # 0xf54b2392
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.landing_blend_time))
data.write(b'W\x01\x8c\xf1') # 0x57018cf1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_crush_push_player))
data.write(b'\xad\xcb\xb4\x94') # 0xadcbb494
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_revive_delay))
data.write(b'\x1b\xf3ZS') # 0x1bf35a53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_revive_limit))
data.write(b'\xa3/>\x1c') # 0xa32f3e1c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_reflate_time))
data.write(b'B\xe8\xf3\xfd') # 0x42e8f3fd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_knock_back_speed))
data.write(b'!?3\x0e') # 0x213f330e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_hurl_height))
data.write(b"r\xb9'\xf9") # 0x72b927f9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_pop_right_velocity))
data.write(b'+2\xb1\xf3') # 0x2b32b1f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_pop_left_velocity))
data.write(b'P\x15\x86\x91') # 0x50158691
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_pop_up_velocity))
data.write(b"\x17'2]") # 0x1727325d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_offset_right))
data.write(b'\xf5\xc7\x08\xa8') # 0xf5c708a8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_offset_left))
data.write(b'm\xcaC<') # 0x6dca433c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_rider_offset_right))
data.write(b'r\xec\xc1#') # 0x72ecc123
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horz_rider_offset_left))
data.write(b'\xf5\x15\xe7\xf6') # 0xf515e7f6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.horz_stop_player))
data.write(b'h\xc4\xb74') # 0x68c4b734
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_revive_delay))
data.write(b'\xde\xfcY\xf3') # 0xdefc59f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_revive_limit))
data.write(b'f =\xbc') # 0x66203dbc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_reflate_time))
data.write(b' \x02\xe0\n') # 0x2002e00a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_knock_back_speed))
data.write(b'\x94\x07-\xb6') # 0x94072db6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_hurl_height))
data.write(b'g\x1b\xae\xcd') # 0x671baecd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_pop_up_velocity))
data.write(b'S6k\xbd') # 0x53366bbd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_pop_down_velocity))
data.write(b'v\x19\x94\x7f') # 0x7619947f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_offset_up))
data.write(b'\t\x03\x1eG') # 0x9031e47
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_offset_down))
data.write(b'\x9bt\x1c\x93') # 0x9b741c93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_rider_offset_up))
data.write(b'\x18\xabD\xd8') # 0x18ab44d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_rider_offset_down))
data.write(b'\x1d\xc4nK') # 0x1dc46e4b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.vert_stop_player))
@classmethod
def from_json(cls, data: dict):
return cls(
shove_limit=data['shove_limit'],
pinch_limit=data['pinch_limit'],
minimum_display_size=data['minimum_display_size'],
failsafe_delay=data['failsafe_delay'],
pre_breakout_buffer=data['pre_breakout_buffer'],
landing_blend_time=data['landing_blend_time'],
can_crush_push_player=data['can_crush_push_player'],
horz_revive_delay=data['horz_revive_delay'],
horz_revive_limit=data['horz_revive_limit'],
horz_reflate_time=data['horz_reflate_time'],
horz_knock_back_speed=data['horz_knock_back_speed'],
horz_hurl_height=data['horz_hurl_height'],
horz_pop_right_velocity=data['horz_pop_right_velocity'],
horz_pop_left_velocity=data['horz_pop_left_velocity'],
horz_pop_up_velocity=data['horz_pop_up_velocity'],
horz_offset_right=data['horz_offset_right'],
horz_offset_left=data['horz_offset_left'],
horz_rider_offset_right=data['horz_rider_offset_right'],
horz_rider_offset_left=data['horz_rider_offset_left'],
horz_stop_player=data['horz_stop_player'],
vert_revive_delay=data['vert_revive_delay'],
vert_revive_limit=data['vert_revive_limit'],
vert_reflate_time=data['vert_reflate_time'],
vert_knock_back_speed=data['vert_knock_back_speed'],
vert_hurl_height=data['vert_hurl_height'],
vert_pop_up_velocity=data['vert_pop_up_velocity'],
vert_pop_down_velocity=data['vert_pop_down_velocity'],
vert_offset_up=data['vert_offset_up'],
vert_offset_down=data['vert_offset_down'],
vert_rider_offset_up=data['vert_rider_offset_up'],
vert_rider_offset_down=data['vert_rider_offset_down'],
vert_stop_player=data['vert_stop_player'],
)
def to_json(self) -> dict:
return {
'shove_limit': self.shove_limit,
'pinch_limit': self.pinch_limit,
'minimum_display_size': self.minimum_display_size,
'failsafe_delay': self.failsafe_delay,
'pre_breakout_buffer': self.pre_breakout_buffer,
'landing_blend_time': self.landing_blend_time,
'can_crush_push_player': self.can_crush_push_player,
'horz_revive_delay': self.horz_revive_delay,
'horz_revive_limit': self.horz_revive_limit,
'horz_reflate_time': self.horz_reflate_time,
'horz_knock_back_speed': self.horz_knock_back_speed,
'horz_hurl_height': self.horz_hurl_height,
'horz_pop_right_velocity': self.horz_pop_right_velocity,
'horz_pop_left_velocity': self.horz_pop_left_velocity,
'horz_pop_up_velocity': self.horz_pop_up_velocity,
'horz_offset_right': self.horz_offset_right,
'horz_offset_left': self.horz_offset_left,
'horz_rider_offset_right': self.horz_rider_offset_right,
'horz_rider_offset_left': self.horz_rider_offset_left,
'horz_stop_player': self.horz_stop_player,
'vert_revive_delay': self.vert_revive_delay,
'vert_revive_limit': self.vert_revive_limit,
'vert_reflate_time': self.vert_reflate_time,
'vert_knock_back_speed': self.vert_knock_back_speed,
'vert_hurl_height': self.vert_hurl_height,
'vert_pop_up_velocity': self.vert_pop_up_velocity,
'vert_pop_down_velocity': self.vert_pop_down_velocity,
'vert_offset_up': self.vert_offset_up,
'vert_offset_down': self.vert_offset_down,
'vert_rider_offset_up': self.vert_rider_offset_up,
'vert_rider_offset_down': self.vert_rider_offset_down,
'vert_stop_player': self.vert_stop_player,
}
_FAST_FORMAT = None
_FAST_IDS = (0x7589789b, 0x7b42fdfa, 0x47f3f101, 0x90aa0d86, 0xe8c4ba9b, 0xf54b2392, 0x57018cf1, 0xadcbb494, 0x1bf35a53, 0xa32f3e1c, 0x42e8f3fd, 0x213f330e, 0x72b927f9, 0x2b32b1f3, 0x50158691, 0x1727325d, 0xf5c708a8, 0x6dca433c, 0x72ecc123, 0xf515e7f6, 0x68c4b734, 0xdefc59f3, 0x66203dbc, 0x2002e00a, 0x94072db6, 0x671baecd, 0x53366bbd, 0x7619947f, 0x9031e47, 0x9b741c93, 0x18ab44d8, 0x1dc46e4b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerCrushData]:
if property_count != 32:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLH?LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLH?LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(311))
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], dec[54], dec[57], dec[60], dec[63], dec[66], dec[69], dec[72], dec[75], dec[78], dec[81], dec[84], dec[87], dec[90], dec[93]) != _FAST_IDS:
data.seek(before)
return None
return PlayerCrushData(
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],
dec[47],
dec[50],
dec[53],
dec[56],
dec[59],
dec[62],
dec[65],
dec[68],
dec[71],
dec[74],
dec[77],
dec[80],
dec[83],
dec[86],
dec[89],
dec[92],
dec[95],
)
def _decode_shove_limit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pinch_limit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_display_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_failsafe_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pre_breakout_buffer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_landing_blend_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_can_crush_push_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_horz_revive_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_revive_limit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_reflate_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_knock_back_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_hurl_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_pop_right_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_pop_left_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_pop_up_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_offset_right(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_offset_left(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_rider_offset_right(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_rider_offset_left(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horz_stop_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_vert_revive_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_revive_limit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_reflate_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_knock_back_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_hurl_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_pop_up_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_pop_down_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_offset_up(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_offset_down(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_rider_offset_up(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_rider_offset_down(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_stop_player(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]]] = {
0x7589789b: ('shove_limit', _decode_shove_limit),
0x7b42fdfa: ('pinch_limit', _decode_pinch_limit),
0x47f3f101: ('minimum_display_size', _decode_minimum_display_size),
0x90aa0d86: ('failsafe_delay', _decode_failsafe_delay),
0xe8c4ba9b: ('pre_breakout_buffer', _decode_pre_breakout_buffer),
0xf54b2392: ('landing_blend_time', _decode_landing_blend_time),
0x57018cf1: ('can_crush_push_player', _decode_can_crush_push_player),
0xadcbb494: ('horz_revive_delay', _decode_horz_revive_delay),
0x1bf35a53: ('horz_revive_limit', _decode_horz_revive_limit),
0xa32f3e1c: ('horz_reflate_time', _decode_horz_reflate_time),
0x42e8f3fd: ('horz_knock_back_speed', _decode_horz_knock_back_speed),
0x213f330e: ('horz_hurl_height', _decode_horz_hurl_height),
0x72b927f9: ('horz_pop_right_velocity', _decode_horz_pop_right_velocity),
0x2b32b1f3: ('horz_pop_left_velocity', _decode_horz_pop_left_velocity),
0x50158691: ('horz_pop_up_velocity', _decode_horz_pop_up_velocity),
0x1727325d: ('horz_offset_right', _decode_horz_offset_right),
0xf5c708a8: ('horz_offset_left', _decode_horz_offset_left),
0x6dca433c: ('horz_rider_offset_right', _decode_horz_rider_offset_right),
0x72ecc123: ('horz_rider_offset_left', _decode_horz_rider_offset_left),
0xf515e7f6: ('horz_stop_player', _decode_horz_stop_player),
0x68c4b734: ('vert_revive_delay', _decode_vert_revive_delay),
0xdefc59f3: ('vert_revive_limit', _decode_vert_revive_limit),
0x66203dbc: ('vert_reflate_time', _decode_vert_reflate_time),
0x2002e00a: ('vert_knock_back_speed', _decode_vert_knock_back_speed),
0x94072db6: ('vert_hurl_height', _decode_vert_hurl_height),
0x671baecd: ('vert_pop_up_velocity', _decode_vert_pop_up_velocity),
0x53366bbd: ('vert_pop_down_velocity', _decode_vert_pop_down_velocity),
0x7619947f: ('vert_offset_up', _decode_vert_offset_up),
0x9031e47: ('vert_offset_down', _decode_vert_offset_down),
0x9b741c93: ('vert_rider_offset_up', _decode_vert_rider_offset_up),
0x18ab44d8: ('vert_rider_offset_down', _decode_vert_rider_offset_down),
0x1dc46e4b: ('vert_stop_player', _decode_vert_stop_player),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerCrushData.py | 0.668231 | 0.298083 | PlayerCrushData.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 KongProxyData(BaseProperty):
unknown_0x9445eea3: bool = dataclasses.field(default=False)
unknown_0x80bc66ea: bool = dataclasses.field(default=False)
unknown_0x30060f67: int = dataclasses.field(default=0)
unknown_0x2f026a4f: int = dataclasses.field(default=0)
gravity_multiplier: float = dataclasses.field(default=0.5)
unknown_0x653fba4a: float = dataclasses.field(default=1.0)
maximum_run_speed: float = dataclasses.field(default=9.0)
acceleration: float = dataclasses.field(default=20.0)
unknown_0x14e317bd: Vector = dataclasses.field(default_factory=lambda: Vector(x=32.0, y=12.0, z=24.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'\x94E\xee\xa3') # 0x9445eea3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x9445eea3))
data.write(b'\x80\xbcf\xea') # 0x80bc66ea
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x80bc66ea))
data.write(b'0\x06\x0fg') # 0x30060f67
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x30060f67))
data.write(b'/\x02jO') # 0x2f026a4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2f026a4f))
data.write(b'B\xacB\xea') # 0x42ac42ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity_multiplier))
data.write(b'e?\xbaJ') # 0x653fba4a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x653fba4a))
data.write(b'\x95\n{\x96') # 0x950a7b96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_run_speed))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x14\xe3\x17\xbd') # 0x14e317bd
data.write(b'\x00\x0c') # size
self.unknown_0x14e317bd.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x9445eea3=data['unknown_0x9445eea3'],
unknown_0x80bc66ea=data['unknown_0x80bc66ea'],
unknown_0x30060f67=data['unknown_0x30060f67'],
unknown_0x2f026a4f=data['unknown_0x2f026a4f'],
gravity_multiplier=data['gravity_multiplier'],
unknown_0x653fba4a=data['unknown_0x653fba4a'],
maximum_run_speed=data['maximum_run_speed'],
acceleration=data['acceleration'],
unknown_0x14e317bd=Vector.from_json(data['unknown_0x14e317bd']),
)
def to_json(self) -> dict:
return {
'unknown_0x9445eea3': self.unknown_0x9445eea3,
'unknown_0x80bc66ea': self.unknown_0x80bc66ea,
'unknown_0x30060f67': self.unknown_0x30060f67,
'unknown_0x2f026a4f': self.unknown_0x2f026a4f,
'gravity_multiplier': self.gravity_multiplier,
'unknown_0x653fba4a': self.unknown_0x653fba4a,
'maximum_run_speed': self.maximum_run_speed,
'acceleration': self.acceleration,
'unknown_0x14e317bd': self.unknown_0x14e317bd.to_json(),
}
def _decode_unknown_0x9445eea3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x80bc66ea(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x30060f67(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2f026a4f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_gravity_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x653fba4a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_run_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x14e317bd(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]]] = {
0x9445eea3: ('unknown_0x9445eea3', _decode_unknown_0x9445eea3),
0x80bc66ea: ('unknown_0x80bc66ea', _decode_unknown_0x80bc66ea),
0x30060f67: ('unknown_0x30060f67', _decode_unknown_0x30060f67),
0x2f026a4f: ('unknown_0x2f026a4f', _decode_unknown_0x2f026a4f),
0x42ac42ea: ('gravity_multiplier', _decode_gravity_multiplier),
0x653fba4a: ('unknown_0x653fba4a', _decode_unknown_0x653fba4a),
0x950a7b96: ('maximum_run_speed', _decode_maximum_run_speed),
0x39fb7978: ('acceleration', _decode_acceleration),
0x14e317bd: ('unknown_0x14e317bd', _decode_unknown_0x14e317bd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongProxyData.py | 0.732209 | 0.331985 | KongProxyData.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 CounterConditions(BaseProperty):
counter_condition1: int = dataclasses.field(default=1)
counter_condition2: int = dataclasses.field(default=2)
counter_condition3: int = dataclasses.field(default=3)
counter_condition4: int = dataclasses.field(default=4)
counter_condition5: int = dataclasses.field(default=5)
counter_condition6: int = dataclasses.field(default=6)
counter_condition7: int = dataclasses.field(default=7)
counter_condition8: int = dataclasses.field(default=8)
counter_condition9: int = dataclasses.field(default=9)
counter_condition10: int = dataclasses.field(default=10)
@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'\x16(\xf2:') # 0x1628f23a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition1))
data.write(b'\x04\x9d]\xd4') # 0x49d5dd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition2))
data.write(b'\xbc!:\xb1') # 0xbc213ab1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition3))
data.write(b'!\xf6\x02\x08') # 0x21f60208
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition4))
data.write(b'\x99Jem') # 0x994a656d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition5))
data.write(b'\x8b\xff\xca\x83') # 0x8bffca83
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition6))
data.write(b'3C\xad\xe6') # 0x3343ade6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition7))
data.write(b'k \xbd\xb0') # 0x6b20bdb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition8))
data.write(b'\xd3\x9c\xda\xd5') # 0xd39cdad5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition9))
data.write(b'\x92\x15\xe8\x13') # 0x9215e813
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.counter_condition10))
@classmethod
def from_json(cls, data: dict):
return cls(
counter_condition1=data['counter_condition1'],
counter_condition2=data['counter_condition2'],
counter_condition3=data['counter_condition3'],
counter_condition4=data['counter_condition4'],
counter_condition5=data['counter_condition5'],
counter_condition6=data['counter_condition6'],
counter_condition7=data['counter_condition7'],
counter_condition8=data['counter_condition8'],
counter_condition9=data['counter_condition9'],
counter_condition10=data['counter_condition10'],
)
def to_json(self) -> dict:
return {
'counter_condition1': self.counter_condition1,
'counter_condition2': self.counter_condition2,
'counter_condition3': self.counter_condition3,
'counter_condition4': self.counter_condition4,
'counter_condition5': self.counter_condition5,
'counter_condition6': self.counter_condition6,
'counter_condition7': self.counter_condition7,
'counter_condition8': self.counter_condition8,
'counter_condition9': self.counter_condition9,
'counter_condition10': self.counter_condition10,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1628f23a, 0x49d5dd4, 0xbc213ab1, 0x21f60208, 0x994a656d, 0x8bffca83, 0x3343ade6, 0x6b20bdb0, 0xd39cdad5, 0x9215e813)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CounterConditions]:
if property_count != 10:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHlLHlLHlLHlLHlLHlLHlLHl')
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 CounterConditions(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
)
def _decode_counter_condition1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_counter_condition10(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]]] = {
0x1628f23a: ('counter_condition1', _decode_counter_condition1),
0x49d5dd4: ('counter_condition2', _decode_counter_condition2),
0xbc213ab1: ('counter_condition3', _decode_counter_condition3),
0x21f60208: ('counter_condition4', _decode_counter_condition4),
0x994a656d: ('counter_condition5', _decode_counter_condition5),
0x8bffca83: ('counter_condition6', _decode_counter_condition6),
0x3343ade6: ('counter_condition7', _decode_counter_condition7),
0x6b20bdb0: ('counter_condition8', _decode_counter_condition8),
0xd39cdad5: ('counter_condition9', _decode_counter_condition9),
0x9215e813: ('counter_condition10', _decode_counter_condition10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CounterConditions.py | 0.581422 | 0.29348 | CounterConditions.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 OffsetSplines(BaseProperty):
local_space: bool = dataclasses.field(default=False)
x_offset: Spline = dataclasses.field(default_factory=Spline)
y_offset: Spline = dataclasses.field(default_factory=Spline)
z_offset: 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\x04') # 4 properties
data.write(b'\x08\xff;D') # 0x8ff3b44
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.local_space))
data.write(b'H[\x0c\x11') # 0x485b0c11
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xcd\xd5\x94') # 0x95cdd594
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x07\xb9Z') # 0x2807b95a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_offset.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(
local_space=data['local_space'],
x_offset=Spline.from_json(data['x_offset']),
y_offset=Spline.from_json(data['y_offset']),
z_offset=Spline.from_json(data['z_offset']),
)
def to_json(self) -> dict:
return {
'local_space': self.local_space,
'x_offset': self.x_offset.to_json(),
'y_offset': self.y_offset.to_json(),
'z_offset': self.z_offset.to_json(),
}
def _decode_local_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_x_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_offset(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]]] = {
0x8ff3b44: ('local_space', _decode_local_space),
0x485b0c11: ('x_offset', _decode_x_offset),
0x95cdd594: ('y_offset', _decode_y_offset),
0x2807b95a: ('z_offset', _decode_z_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OffsetSplines.py | 0.658198 | 0.331444 | OffsetSplines.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.MaterialType import MaterialType
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 MineCartMaterialSounds(BaseProperty):
material: MaterialType = dataclasses.field(default_factory=MaterialType)
rolling_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rolling_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
rolling_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
rolling_sound_volume: Spline = dataclasses.field(default_factory=Spline)
rolling_sound2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
rolling_sound2_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
rolling_sound2_pitch: Spline = dataclasses.field(default_factory=Spline)
rolling_sound2_volume: Spline = dataclasses.field(default_factory=Spline)
jump_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
land_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\x0b') # 11 properties
data.write(b'\xd7.\t\xe1') # 0xd72e09e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xb1\xad\xd6') # 0x36b1add6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rolling_sound))
data.write(b'\xef\xe4y\x8f') # 0xefe4798f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_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'\x96\xd4\xf7\x8b') # 0x96d4f78b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_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'\x15\x00\x1e\r') # 0x15001e0d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe3\xa61\x00') # 0xe3a63100
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rolling_sound2))
data.write(b';\x01l\xfa') # 0x3b016cfa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound2_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'\x00\xc9ZU') # 0xc95a55
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound2_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b't\xfd\xfcs') # 0x74fdfc73
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rolling_sound2_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xe6`\xaf') # 0xebe660af
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.jump_sound))
data.write(b'\x0e+\x82\xec') # 0xe2b82ec
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.land_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
material=MaterialType.from_json(data['material']),
rolling_sound=data['rolling_sound'],
rolling_sound_low_pass_filter=Spline.from_json(data['rolling_sound_low_pass_filter']),
rolling_sound_pitch=Spline.from_json(data['rolling_sound_pitch']),
rolling_sound_volume=Spline.from_json(data['rolling_sound_volume']),
rolling_sound2=data['rolling_sound2'],
rolling_sound2_low_pass_filter=Spline.from_json(data['rolling_sound2_low_pass_filter']),
rolling_sound2_pitch=Spline.from_json(data['rolling_sound2_pitch']),
rolling_sound2_volume=Spline.from_json(data['rolling_sound2_volume']),
jump_sound=data['jump_sound'],
land_sound=data['land_sound'],
)
def to_json(self) -> dict:
return {
'material': self.material.to_json(),
'rolling_sound': self.rolling_sound,
'rolling_sound_low_pass_filter': self.rolling_sound_low_pass_filter.to_json(),
'rolling_sound_pitch': self.rolling_sound_pitch.to_json(),
'rolling_sound_volume': self.rolling_sound_volume.to_json(),
'rolling_sound2': self.rolling_sound2,
'rolling_sound2_low_pass_filter': self.rolling_sound2_low_pass_filter.to_json(),
'rolling_sound2_pitch': self.rolling_sound2_pitch.to_json(),
'rolling_sound2_volume': self.rolling_sound2_volume.to_json(),
'jump_sound': self.jump_sound,
'land_sound': self.land_sound,
}
def _decode_material(data: typing.BinaryIO, property_size: int):
return MaterialType.from_stream(data, property_size)
def _decode_rolling_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rolling_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rolling_sound2_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound2_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_rolling_sound2_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_jump_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_land_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]]] = {
0xd72e09e1: ('material', _decode_material),
0x36b1add6: ('rolling_sound', _decode_rolling_sound),
0xefe4798f: ('rolling_sound_low_pass_filter', _decode_rolling_sound_low_pass_filter),
0x96d4f78b: ('rolling_sound_pitch', _decode_rolling_sound_pitch),
0x15001e0d: ('rolling_sound_volume', _decode_rolling_sound_volume),
0xe3a63100: ('rolling_sound2', _decode_rolling_sound2),
0x3b016cfa: ('rolling_sound2_low_pass_filter', _decode_rolling_sound2_low_pass_filter),
0xc95a55: ('rolling_sound2_pitch', _decode_rolling_sound2_pitch),
0x74fdfc73: ('rolling_sound2_volume', _decode_rolling_sound2_volume),
0xebe660af: ('jump_sound', _decode_jump_sound),
0xe2b82ec: ('land_sound', _decode_land_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MineCartMaterialSounds.py | 0.507812 | 0.26061 | MineCartMaterialSounds.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 UnknownStruct265(BaseProperty):
dominance: enums.Dominance = dataclasses.field(default=enums.Dominance.Unknown1)
unknown_0x60d9b1cc: bool = dataclasses.field(default=True)
acceleration_frame: enums.AccelerationFrame = dataclasses.field(default=enums.AccelerationFrame.Unknown1)
movement_acceleration: float = dataclasses.field(default=0.0)
max_movement_speed: float = dataclasses.field(default=0.0)
passive_acceleration: float = dataclasses.field(default=0.0)
max_passive_speed: float = dataclasses.field(default=0.0)
stopped_threshold: float = dataclasses.field(default=0.009999999776482582)
unknown_0x91b27cb3: float = dataclasses.field(default=0.0)
balanced_velocity_percentage: Spline = dataclasses.field(default_factory=Spline)
unknown_0xc355fb9f: float = dataclasses.field(default=0.0)
unknown_0x3153f656: 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\x0c') # 12 properties
data.write(b'\xc2\xea|\x93') # 0xc2ea7c93
data.write(b'\x00\x04') # size
self.dominance.to_stream(data)
data.write(b'`\xd9\xb1\xcc') # 0x60d9b1cc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x60d9b1cc))
data.write(b'\xe3\xa1\xbe1') # 0xe3a1be31
data.write(b'\x00\x04') # size
self.acceleration_frame.to_stream(data)
data.write(b'\xfb\\\xf51') # 0xfb5cf531
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.movement_acceleration))
data.write(b'\x00L\xabd') # 0x4cab64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_movement_speed))
data.write(b'&(\x88I') # 0x26288849
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.passive_acceleration))
data.write(b'Q\xb0="') # 0x51b03d22
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_passive_speed))
data.write(b'U\x05t\xf2') # 0x550574f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stopped_threshold))
data.write(b'\x91\xb2|\xb3') # 0x91b27cb3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x91b27cb3))
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'\xc3U\xfb\x9f') # 0xc355fb9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc355fb9f))
data.write(b'1S\xf6V') # 0x3153f656
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x3153f656.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(
dominance=enums.Dominance.from_json(data['dominance']),
unknown_0x60d9b1cc=data['unknown_0x60d9b1cc'],
acceleration_frame=enums.AccelerationFrame.from_json(data['acceleration_frame']),
movement_acceleration=data['movement_acceleration'],
max_movement_speed=data['max_movement_speed'],
passive_acceleration=data['passive_acceleration'],
max_passive_speed=data['max_passive_speed'],
stopped_threshold=data['stopped_threshold'],
unknown_0x91b27cb3=data['unknown_0x91b27cb3'],
balanced_velocity_percentage=Spline.from_json(data['balanced_velocity_percentage']),
unknown_0xc355fb9f=data['unknown_0xc355fb9f'],
unknown_0x3153f656=Spline.from_json(data['unknown_0x3153f656']),
)
def to_json(self) -> dict:
return {
'dominance': self.dominance.to_json(),
'unknown_0x60d9b1cc': self.unknown_0x60d9b1cc,
'acceleration_frame': self.acceleration_frame.to_json(),
'movement_acceleration': self.movement_acceleration,
'max_movement_speed': self.max_movement_speed,
'passive_acceleration': self.passive_acceleration,
'max_passive_speed': self.max_passive_speed,
'stopped_threshold': self.stopped_threshold,
'unknown_0x91b27cb3': self.unknown_0x91b27cb3,
'balanced_velocity_percentage': self.balanced_velocity_percentage.to_json(),
'unknown_0xc355fb9f': self.unknown_0xc355fb9f,
'unknown_0x3153f656': self.unknown_0x3153f656.to_json(),
}
def _decode_dominance(data: typing.BinaryIO, property_size: int):
return enums.Dominance.from_stream(data)
def _decode_unknown_0x60d9b1cc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_acceleration_frame(data: typing.BinaryIO, property_size: int):
return enums.AccelerationFrame.from_stream(data)
def _decode_movement_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_movement_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_passive_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_passive_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stopped_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x91b27cb3(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_unknown_0xc355fb9f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3153f656(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]]] = {
0xc2ea7c93: ('dominance', _decode_dominance),
0x60d9b1cc: ('unknown_0x60d9b1cc', _decode_unknown_0x60d9b1cc),
0xe3a1be31: ('acceleration_frame', _decode_acceleration_frame),
0xfb5cf531: ('movement_acceleration', _decode_movement_acceleration),
0x4cab64: ('max_movement_speed', _decode_max_movement_speed),
0x26288849: ('passive_acceleration', _decode_passive_acceleration),
0x51b03d22: ('max_passive_speed', _decode_max_passive_speed),
0x550574f2: ('stopped_threshold', _decode_stopped_threshold),
0x91b27cb3: ('unknown_0x91b27cb3', _decode_unknown_0x91b27cb3),
0x59299e65: ('balanced_velocity_percentage', _decode_balanced_velocity_percentage),
0xc355fb9f: ('unknown_0xc355fb9f', _decode_unknown_0xc355fb9f),
0x3153f656: ('unknown_0x3153f656', _decode_unknown_0x3153f656),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct265.py | 0.70304 | 0.310717 | UnknownStruct265.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.