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
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
from retro_data_structures.properties.dkc_returns.archetypes.OffsetInterpolant import OffsetInterpolant
@dataclasses.dataclass()
class SurfacePosition(BaseProperty):
flags_surface_position: int = dataclasses.field(default=1)
player_offset: OffsetInterpolant = dataclasses.field(default_factory=OffsetInterpolant)
convergence: Convergence = dataclasses.field(default_factory=Convergence)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x9d\x99\xb2\xe3') # 0x9d99b2e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_surface_position))
data.write(b'\xe6\x9cQ\xd7') # 0xe69c51d7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_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\x91\x08\xa5') # 0x959108a5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
flags_surface_position=data['flags_surface_position'],
player_offset=OffsetInterpolant.from_json(data['player_offset']),
convergence=Convergence.from_json(data['convergence']),
)
def to_json(self) -> dict:
return {
'flags_surface_position': self.flags_surface_position,
'player_offset': self.player_offset.to_json(),
'convergence': self.convergence.to_json(),
}
def _decode_flags_surface_position(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_player_offset(data: typing.BinaryIO, property_size: int):
return OffsetInterpolant.from_stream(data, property_size)
def _decode_convergence(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9d99b2e3: ('flags_surface_position', _decode_flags_surface_position),
0xe69c51d7: ('player_offset', _decode_player_offset),
0x959108a5: ('convergence', _decode_convergence),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SurfacePosition.py | 0.660829 | 0.298051 | SurfacePosition.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 UnknownStruct96(BaseProperty):
spawn_as_group: bool = dataclasses.field(default=True)
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]
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'\x16\x87\x10\xad') # 0x168710ad
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spawn_as_group))
data.write(b'\xbcv\xf3,') # 0xbc76f32c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
spawn_as_group=data['spawn_as_group'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'spawn_as_group': self.spawn_as_group,
'unknown': self.unknown,
}
_FAST_FORMAT = None
_FAST_IDS = (0x168710ad, 0xbc76f32c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct96]:
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 UnknownStruct96(
dec[2],
dec[5],
)
def _decode_spawn_as_group(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x168710ad: ('spawn_as_group', _decode_spawn_as_group),
0xbc76f32c: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct96.py | 0.611962 | 0.318313 | UnknownStruct96.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.BouncyTireJumpHeights import BouncyTireJumpHeights
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
@dataclasses.dataclass()
class BouncyTireData(BaseProperty):
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
idle_animation: int = dataclasses.field(default=0)
spring_animation: int = dataclasses.field(default=0)
left_jiggle_animation: int = dataclasses.field(default=0)
right_jiggle_animation: int = dataclasses.field(default=0)
bounce_height: float = dataclasses.field(default=3.140199899673462)
normal_jump_heights: BouncyTireJumpHeights = dataclasses.field(default_factory=BouncyTireJumpHeights)
tar_inhibited_jump_heights: BouncyTireJumpHeights = dataclasses.field(default_factory=BouncyTireJumpHeights)
high_jump_max_velocity_x: float = dataclasses.field(default=9.0)
mass: float = dataclasses.field(default=80.0)
rider_stop_speed_threshold: float = dataclasses.field(default=5.0)
bounce_detection_angle: float = dataclasses.field(default=45.0)
bounce_sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
jump_sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
is_stationary: bool = dataclasses.field(default=True)
should_cancel_players_momentum: bool = dataclasses.field(default=False)
unknown_0x592fc47e: bool = dataclasses.field(default=False)
should_absorb_shadows: bool = dataclasses.field(default=False)
unknown_0x9d837da5: bool = dataclasses.field(default=True)
air_control_disabled_duration_on_low_bounce: float = dataclasses.field(default=0.0)
air_control_disabled_duration_on_high_bounce: float = dataclasses.field(default=0.0)
air_control_scalar_on_high_bounce: float = dataclasses.field(default=2.0)
air_control_scalar_on_low_bounce: float = dataclasses.field(default=2.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x18') # 24 properties
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2\xa5\xb3\x8f') # 0xa2a5b38f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.idle_animation))
data.write(b'\rXJ\x11') # 0xd584a11
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.spring_animation))
data.write(b'\xcb\x191\xf5') # 0xcb1931f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.left_jiggle_animation))
data.write(b'db\x90z') # 0x6462907a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.right_jiggle_animation))
data.write(b'/RO\xd4') # 0x2f524fd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_height))
data.write(b'\x19(w7') # 0x19287737
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal_jump_heights.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'j:\xfc\x9e') # 0x6a3afc9e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tar_inhibited_jump_heights.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x83\xa5):') # 0x83a5293a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.high_jump_max_velocity_x))
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'OjT\x03') # 0x4f6a5403
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rider_stop_speed_threshold))
data.write(b'\xa8\xe4n\xa2') # 0xa8e46ea2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_detection_angle))
data.write(b'i\x15o\xbe') # 0x69156fbe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_sound_effect))
data.write(b'\xc0\t\x04\xc2') # 0xc00904c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.jump_sound_effect))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xab.V\xf4') # 0xab2e56f4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_stationary))
data.write(b't\x92\x0e\x0e') # 0x74920e0e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.should_cancel_players_momentum))
data.write(b'Y/\xc4~') # 0x592fc47e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x592fc47e))
data.write(b'\x82\xd1\x131') # 0x82d11331
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.should_absorb_shadows))
data.write(b'\x9d\x83}\xa5') # 0x9d837da5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x9d837da5))
data.write(b'=\x04\xe5\x92') # 0x3d04e592
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_control_disabled_duration_on_low_bounce))
data.write(b'5\x95\xd9w') # 0x3595d977
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_control_disabled_duration_on_high_bounce))
data.write(b'\xd5P^\xa4') # 0xd5505ea4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_control_scalar_on_high_bounce))
data.write(b'-j(\x98') # 0x2d6a2898
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_control_scalar_on_low_bounce))
@classmethod
def from_json(cls, data: dict):
return cls(
animation=AnimationParameters.from_json(data['animation']),
idle_animation=data['idle_animation'],
spring_animation=data['spring_animation'],
left_jiggle_animation=data['left_jiggle_animation'],
right_jiggle_animation=data['right_jiggle_animation'],
bounce_height=data['bounce_height'],
normal_jump_heights=BouncyTireJumpHeights.from_json(data['normal_jump_heights']),
tar_inhibited_jump_heights=BouncyTireJumpHeights.from_json(data['tar_inhibited_jump_heights']),
high_jump_max_velocity_x=data['high_jump_max_velocity_x'],
mass=data['mass'],
rider_stop_speed_threshold=data['rider_stop_speed_threshold'],
bounce_detection_angle=data['bounce_detection_angle'],
bounce_sound_effect=data['bounce_sound_effect'],
jump_sound_effect=data['jump_sound_effect'],
collision_model=data['collision_model'],
is_stationary=data['is_stationary'],
should_cancel_players_momentum=data['should_cancel_players_momentum'],
unknown_0x592fc47e=data['unknown_0x592fc47e'],
should_absorb_shadows=data['should_absorb_shadows'],
unknown_0x9d837da5=data['unknown_0x9d837da5'],
air_control_disabled_duration_on_low_bounce=data['air_control_disabled_duration_on_low_bounce'],
air_control_disabled_duration_on_high_bounce=data['air_control_disabled_duration_on_high_bounce'],
air_control_scalar_on_high_bounce=data['air_control_scalar_on_high_bounce'],
air_control_scalar_on_low_bounce=data['air_control_scalar_on_low_bounce'],
)
def to_json(self) -> dict:
return {
'animation': self.animation.to_json(),
'idle_animation': self.idle_animation,
'spring_animation': self.spring_animation,
'left_jiggle_animation': self.left_jiggle_animation,
'right_jiggle_animation': self.right_jiggle_animation,
'bounce_height': self.bounce_height,
'normal_jump_heights': self.normal_jump_heights.to_json(),
'tar_inhibited_jump_heights': self.tar_inhibited_jump_heights.to_json(),
'high_jump_max_velocity_x': self.high_jump_max_velocity_x,
'mass': self.mass,
'rider_stop_speed_threshold': self.rider_stop_speed_threshold,
'bounce_detection_angle': self.bounce_detection_angle,
'bounce_sound_effect': self.bounce_sound_effect,
'jump_sound_effect': self.jump_sound_effect,
'collision_model': self.collision_model,
'is_stationary': self.is_stationary,
'should_cancel_players_momentum': self.should_cancel_players_momentum,
'unknown_0x592fc47e': self.unknown_0x592fc47e,
'should_absorb_shadows': self.should_absorb_shadows,
'unknown_0x9d837da5': self.unknown_0x9d837da5,
'air_control_disabled_duration_on_low_bounce': self.air_control_disabled_duration_on_low_bounce,
'air_control_disabled_duration_on_high_bounce': self.air_control_disabled_duration_on_high_bounce,
'air_control_scalar_on_high_bounce': self.air_control_scalar_on_high_bounce,
'air_control_scalar_on_low_bounce': self.air_control_scalar_on_low_bounce,
}
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_idle_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spring_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_left_jiggle_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_right_jiggle_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_bounce_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_normal_jump_heights(data: typing.BinaryIO, property_size: int):
return BouncyTireJumpHeights.from_stream(data, property_size)
def _decode_tar_inhibited_jump_heights(data: typing.BinaryIO, property_size: int):
return BouncyTireJumpHeights.from_stream(data, property_size)
def _decode_high_jump_max_velocity_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rider_stop_speed_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_jump_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_is_stationary(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_should_cancel_players_momentum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x592fc47e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_should_absorb_shadows(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x9d837da5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_air_control_disabled_duration_on_low_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_air_control_disabled_duration_on_high_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_air_control_scalar_on_high_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_air_control_scalar_on_low_bounce(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]]] = {
0xa3d63f44: ('animation', _decode_animation),
0xa2a5b38f: ('idle_animation', _decode_idle_animation),
0xd584a11: ('spring_animation', _decode_spring_animation),
0xcb1931f5: ('left_jiggle_animation', _decode_left_jiggle_animation),
0x6462907a: ('right_jiggle_animation', _decode_right_jiggle_animation),
0x2f524fd4: ('bounce_height', _decode_bounce_height),
0x19287737: ('normal_jump_heights', _decode_normal_jump_heights),
0x6a3afc9e: ('tar_inhibited_jump_heights', _decode_tar_inhibited_jump_heights),
0x83a5293a: ('high_jump_max_velocity_x', _decode_high_jump_max_velocity_x),
0x75dbb375: ('mass', _decode_mass),
0x4f6a5403: ('rider_stop_speed_threshold', _decode_rider_stop_speed_threshold),
0xa8e46ea2: ('bounce_detection_angle', _decode_bounce_detection_angle),
0x69156fbe: ('bounce_sound_effect', _decode_bounce_sound_effect),
0xc00904c2: ('jump_sound_effect', _decode_jump_sound_effect),
0xfc966dc: ('collision_model', _decode_collision_model),
0xab2e56f4: ('is_stationary', _decode_is_stationary),
0x74920e0e: ('should_cancel_players_momentum', _decode_should_cancel_players_momentum),
0x592fc47e: ('unknown_0x592fc47e', _decode_unknown_0x592fc47e),
0x82d11331: ('should_absorb_shadows', _decode_should_absorb_shadows),
0x9d837da5: ('unknown_0x9d837da5', _decode_unknown_0x9d837da5),
0x3d04e592: ('air_control_disabled_duration_on_low_bounce', _decode_air_control_disabled_duration_on_low_bounce),
0x3595d977: ('air_control_disabled_duration_on_high_bounce', _decode_air_control_disabled_duration_on_high_bounce),
0xd5505ea4: ('air_control_scalar_on_high_bounce', _decode_air_control_scalar_on_high_bounce),
0x2d6a2898: ('air_control_scalar_on_low_bounce', _decode_air_control_scalar_on_low_bounce),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BouncyTireData.py | 0.605333 | 0.255468 | BouncyTireData.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 UnknownStruct161(BaseProperty):
unknown_0xac6cbf9d: float = dataclasses.field(default=0.0)
initial_duration: float = dataclasses.field(default=0.25)
reveal_title_duration: float = dataclasses.field(default=0.25)
unknown_0x34e18255: float = dataclasses.field(default=0.25)
unknown_0x892ae90a: float = dataclasses.field(default=0.25)
unknown_0x5bed9219: float = dataclasses.field(default=0.25)
unknown_0x039bddff: float = dataclasses.field(default=0.25)
unknown_0x48b54a2f: float = dataclasses.field(default=0.25)
unknown_0x81402f46: float = dataclasses.field(default=0.25)
unknown_0xe328a2c3: float = dataclasses.field(default=0.25)
unknown_0xcab973a9: float = dataclasses.field(default=0.25)
unknown_0x407911ad: float = dataclasses.field(default=0.25)
reveal_buttons_duration: float = dataclasses.field(default=0.25)
unknown_0xf0c51c84: 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]
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\x0e') # 14 properties
data.write(b'\xacl\xbf\x9d') # 0xac6cbf9d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xac6cbf9d))
data.write(b'\x08\xe6\xc4/') # 0x8e6c42f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_duration))
data.write(b'\x04\xa4\xacL') # 0x4a4ac4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reveal_title_duration))
data.write(b'4\xe1\x82U') # 0x34e18255
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x34e18255))
data.write(b'\x89*\xe9\n') # 0x892ae90a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x892ae90a))
data.write(b'[\xed\x92\x19') # 0x5bed9219
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5bed9219))
data.write(b'\x03\x9b\xdd\xff') # 0x39bddff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x039bddff))
data.write(b'H\xb5J/') # 0x48b54a2f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x48b54a2f))
data.write(b'\x81@/F') # 0x81402f46
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x81402f46))
data.write(b'\xe3(\xa2\xc3') # 0xe328a2c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe328a2c3))
data.write(b'\xca\xb9s\xa9') # 0xcab973a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcab973a9))
data.write(b'@y\x11\xad') # 0x407911ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x407911ad))
data.write(b'm_\xd4W') # 0x6d5fd457
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reveal_buttons_duration))
data.write(b'\xf0\xc5\x1c\x84') # 0xf0c51c84
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf0c51c84))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xac6cbf9d=data['unknown_0xac6cbf9d'],
initial_duration=data['initial_duration'],
reveal_title_duration=data['reveal_title_duration'],
unknown_0x34e18255=data['unknown_0x34e18255'],
unknown_0x892ae90a=data['unknown_0x892ae90a'],
unknown_0x5bed9219=data['unknown_0x5bed9219'],
unknown_0x039bddff=data['unknown_0x039bddff'],
unknown_0x48b54a2f=data['unknown_0x48b54a2f'],
unknown_0x81402f46=data['unknown_0x81402f46'],
unknown_0xe328a2c3=data['unknown_0xe328a2c3'],
unknown_0xcab973a9=data['unknown_0xcab973a9'],
unknown_0x407911ad=data['unknown_0x407911ad'],
reveal_buttons_duration=data['reveal_buttons_duration'],
unknown_0xf0c51c84=data['unknown_0xf0c51c84'],
)
def to_json(self) -> dict:
return {
'unknown_0xac6cbf9d': self.unknown_0xac6cbf9d,
'initial_duration': self.initial_duration,
'reveal_title_duration': self.reveal_title_duration,
'unknown_0x34e18255': self.unknown_0x34e18255,
'unknown_0x892ae90a': self.unknown_0x892ae90a,
'unknown_0x5bed9219': self.unknown_0x5bed9219,
'unknown_0x039bddff': self.unknown_0x039bddff,
'unknown_0x48b54a2f': self.unknown_0x48b54a2f,
'unknown_0x81402f46': self.unknown_0x81402f46,
'unknown_0xe328a2c3': self.unknown_0xe328a2c3,
'unknown_0xcab973a9': self.unknown_0xcab973a9,
'unknown_0x407911ad': self.unknown_0x407911ad,
'reveal_buttons_duration': self.reveal_buttons_duration,
'unknown_0xf0c51c84': self.unknown_0xf0c51c84,
}
_FAST_FORMAT = None
_FAST_IDS = (0xac6cbf9d, 0x8e6c42f, 0x4a4ac4c, 0x34e18255, 0x892ae90a, 0x5bed9219, 0x39bddff, 0x48b54a2f, 0x81402f46, 0xe328a2c3, 0xcab973a9, 0x407911ad, 0x6d5fd457, 0xf0c51c84)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct161]:
if property_count != 14:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(140))
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]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct161(
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],
)
def _decode_unknown_0xac6cbf9d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reveal_title_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x34e18255(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x892ae90a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5bed9219(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x039bddff(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x48b54a2f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x81402f46(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe328a2c3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcab973a9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x407911ad(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_reveal_buttons_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf0c51c84(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]]] = {
0xac6cbf9d: ('unknown_0xac6cbf9d', _decode_unknown_0xac6cbf9d),
0x8e6c42f: ('initial_duration', _decode_initial_duration),
0x4a4ac4c: ('reveal_title_duration', _decode_reveal_title_duration),
0x34e18255: ('unknown_0x34e18255', _decode_unknown_0x34e18255),
0x892ae90a: ('unknown_0x892ae90a', _decode_unknown_0x892ae90a),
0x5bed9219: ('unknown_0x5bed9219', _decode_unknown_0x5bed9219),
0x39bddff: ('unknown_0x039bddff', _decode_unknown_0x039bddff),
0x48b54a2f: ('unknown_0x48b54a2f', _decode_unknown_0x48b54a2f),
0x81402f46: ('unknown_0x81402f46', _decode_unknown_0x81402f46),
0xe328a2c3: ('unknown_0xe328a2c3', _decode_unknown_0xe328a2c3),
0xcab973a9: ('unknown_0xcab973a9', _decode_unknown_0xcab973a9),
0x407911ad: ('unknown_0x407911ad', _decode_unknown_0x407911ad),
0x6d5fd457: ('reveal_buttons_duration', _decode_reveal_buttons_duration),
0xf0c51c84: ('unknown_0xf0c51c84', _decode_unknown_0xf0c51c84),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct161.py | 0.621541 | 0.273811 | UnknownStruct161.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.UnknownStruct149 import UnknownStruct149
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct150 import UnknownStruct150
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct151 import UnknownStruct151
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct34 import UnknownStruct34
@dataclasses.dataclass()
class PauseHUD(BaseProperty):
unknown_struct149: UnknownStruct149 = dataclasses.field(default_factory=UnknownStruct149)
unknown_struct150: UnknownStruct150 = dataclasses.field(default_factory=UnknownStruct150)
unknown_struct151: UnknownStruct151 = dataclasses.field(default_factory=UnknownStruct151)
unknown_struct34: UnknownStruct34 = dataclasses.field(default_factory=UnknownStruct34)
@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'\xeb\x03\x16\x8d') # 0xeb03168d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct149.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc\xd8TV') # 0xccd85456
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct150.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\x83\x15\xcc') # 0xb48315cc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct151.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb5M\xd0\x84') # 0xb54dd084
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct34.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_struct149=UnknownStruct149.from_json(data['unknown_struct149']),
unknown_struct150=UnknownStruct150.from_json(data['unknown_struct150']),
unknown_struct151=UnknownStruct151.from_json(data['unknown_struct151']),
unknown_struct34=UnknownStruct34.from_json(data['unknown_struct34']),
)
def to_json(self) -> dict:
return {
'unknown_struct149': self.unknown_struct149.to_json(),
'unknown_struct150': self.unknown_struct150.to_json(),
'unknown_struct151': self.unknown_struct151.to_json(),
'unknown_struct34': self.unknown_struct34.to_json(),
}
def _decode_unknown_struct149(data: typing.BinaryIO, property_size: int):
return UnknownStruct149.from_stream(data, property_size)
def _decode_unknown_struct150(data: typing.BinaryIO, property_size: int):
return UnknownStruct150.from_stream(data, property_size)
def _decode_unknown_struct151(data: typing.BinaryIO, property_size: int):
return UnknownStruct151.from_stream(data, property_size)
def _decode_unknown_struct34(data: typing.BinaryIO, property_size: int):
return UnknownStruct34.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xeb03168d: ('unknown_struct149', _decode_unknown_struct149),
0xccd85456: ('unknown_struct150', _decode_unknown_struct150),
0xb48315cc: ('unknown_struct151', _decode_unknown_struct151),
0xb54dd084: ('unknown_struct34', _decode_unknown_struct34),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PauseHUD.py | 0.621771 | 0.293079 | PauseHUD.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.TweakGraphicalTransitions.UnknownStruct2 import UnknownStruct2
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 DeathTikiTransition(BaseProperty):
background: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
tiki_face: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
time_attack_stop_watch: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
black_screen: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
swirl: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
start_mask: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
end_mask: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
balloon_board: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
text_font_name: str = dataclasses.field(default='')
text_gradient_start_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
text_gradient_end_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
text_outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
text_decrement_time: float = dataclasses.field(default=1.0)
text_pos_x: float = dataclasses.field(default=0.0)
text_pos_y: float = dataclasses.field(default=0.0)
model_camera_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model_look_at_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
balloon_start_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
super_guide_dk_start_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
super_guide_anim_delay: float = dataclasses.field(default=0.0)
balloon_velocity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
quit_button_position: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
game_over_text_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
button_text_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\x18') # 24 properties
data.write(b'x\xa6\x16G') # 0x78a61647
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.background.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d\xeaLd') # 0x8dea4c64
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tiki_face.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\xda\xfd\xc8') # 0xb9dafdc8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.time_attack_stop_watch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xc6\xc0<') # 0x64c6c03c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.black_screen.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'4yz ') # 0x34797a20
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swirl.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa6\x81\xd6U') # 0xa681d655
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.start_mask.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\x0c\x91\x1d') # 0x930c911d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.end_mask.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[vb\xce') # 0x5b7662ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balloon_board.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9k\xa9J') # 0xc96ba94a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.text_font_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'\xf9\xe0\xd0\xfb') # 0xf9e0d0fb
data.write(b'\x00\x10') # size
self.text_gradient_start_color.to_stream(data)
data.write(b'\xe0A~\x89') # 0xe0417e89
data.write(b'\x00\x10') # size
self.text_gradient_end_color.to_stream(data)
data.write(b'\xf2\xe15\x06') # 0xf2e13506
data.write(b'\x00\x10') # size
self.text_outline_color.to_stream(data)
data.write(b'\x9c\xd3]i') # 0x9cd35d69
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_decrement_time))
data.write(b'{Is\x13') # 0x7b497313
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_pos_x))
data.write(b'\xb0\x15\xa0\xb6') # 0xb015a0b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_pos_y))
data.write(b'\x0e\xd3\xbb\xa6') # 0xed3bba6
data.write(b'\x00\x0c') # size
self.model_camera_pos.to_stream(data)
data.write(b'h\xa2,_') # 0x68a22c5f
data.write(b'\x00\x0c') # size
self.model_look_at_pos.to_stream(data)
data.write(b'\xf9n\x96\xa8') # 0xf96e96a8
data.write(b'\x00\x0c') # size
self.balloon_start_pos.to_stream(data)
data.write(b'\xb65\xe8\xb7') # 0xb635e8b7
data.write(b'\x00\x0c') # size
self.super_guide_dk_start_pos.to_stream(data)
data.write(b'ji\xaa\x8c') # 0x6a69aa8c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.super_guide_anim_delay))
data.write(b'-\xd0\x91\x93') # 0x2dd09193
data.write(b'\x00\x0c') # size
self.balloon_velocity.to_stream(data)
data.write(b'\xbd]#\x95') # 0xbd5d2395
data.write(b'\x00\x0c') # size
self.quit_button_position.to_stream(data)
data.write(b'\x92\x1b\x9c\xdc') # 0x921b9cdc
data.write(b'\x00\x0c') # size
self.game_over_text_pos.to_stream(data)
data.write(b'\x92\xbe\x12\xe9') # 0x92be12e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.button_text_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(
background=UnknownStruct2.from_json(data['background']),
tiki_face=UnknownStruct2.from_json(data['tiki_face']),
time_attack_stop_watch=UnknownStruct2.from_json(data['time_attack_stop_watch']),
black_screen=UnknownStruct2.from_json(data['black_screen']),
swirl=UnknownStruct2.from_json(data['swirl']),
start_mask=UnknownStruct2.from_json(data['start_mask']),
end_mask=UnknownStruct2.from_json(data['end_mask']),
balloon_board=UnknownStruct2.from_json(data['balloon_board']),
text_font_name=data['text_font_name'],
text_gradient_start_color=Color.from_json(data['text_gradient_start_color']),
text_gradient_end_color=Color.from_json(data['text_gradient_end_color']),
text_outline_color=Color.from_json(data['text_outline_color']),
text_decrement_time=data['text_decrement_time'],
text_pos_x=data['text_pos_x'],
text_pos_y=data['text_pos_y'],
model_camera_pos=Vector.from_json(data['model_camera_pos']),
model_look_at_pos=Vector.from_json(data['model_look_at_pos']),
balloon_start_pos=Vector.from_json(data['balloon_start_pos']),
super_guide_dk_start_pos=Vector.from_json(data['super_guide_dk_start_pos']),
super_guide_anim_delay=data['super_guide_anim_delay'],
balloon_velocity=Vector.from_json(data['balloon_velocity']),
quit_button_position=Vector.from_json(data['quit_button_position']),
game_over_text_pos=Vector.from_json(data['game_over_text_pos']),
button_text_locator=data['button_text_locator'],
)
def to_json(self) -> dict:
return {
'background': self.background.to_json(),
'tiki_face': self.tiki_face.to_json(),
'time_attack_stop_watch': self.time_attack_stop_watch.to_json(),
'black_screen': self.black_screen.to_json(),
'swirl': self.swirl.to_json(),
'start_mask': self.start_mask.to_json(),
'end_mask': self.end_mask.to_json(),
'balloon_board': self.balloon_board.to_json(),
'text_font_name': self.text_font_name,
'text_gradient_start_color': self.text_gradient_start_color.to_json(),
'text_gradient_end_color': self.text_gradient_end_color.to_json(),
'text_outline_color': self.text_outline_color.to_json(),
'text_decrement_time': self.text_decrement_time,
'text_pos_x': self.text_pos_x,
'text_pos_y': self.text_pos_y,
'model_camera_pos': self.model_camera_pos.to_json(),
'model_look_at_pos': self.model_look_at_pos.to_json(),
'balloon_start_pos': self.balloon_start_pos.to_json(),
'super_guide_dk_start_pos': self.super_guide_dk_start_pos.to_json(),
'super_guide_anim_delay': self.super_guide_anim_delay,
'balloon_velocity': self.balloon_velocity.to_json(),
'quit_button_position': self.quit_button_position.to_json(),
'game_over_text_pos': self.game_over_text_pos.to_json(),
'button_text_locator': self.button_text_locator,
}
def _decode_background(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_tiki_face(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_time_attack_stop_watch(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_black_screen(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_swirl(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_start_mask(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_end_mask(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_balloon_board(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_text_font_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_text_gradient_start_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_gradient_end_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_decrement_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_text_pos_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_text_pos_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model_camera_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model_look_at_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_balloon_start_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_super_guide_dk_start_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_super_guide_anim_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_balloon_velocity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_quit_button_position(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_game_over_text_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_button_text_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]]] = {
0x78a61647: ('background', _decode_background),
0x8dea4c64: ('tiki_face', _decode_tiki_face),
0xb9dafdc8: ('time_attack_stop_watch', _decode_time_attack_stop_watch),
0x64c6c03c: ('black_screen', _decode_black_screen),
0x34797a20: ('swirl', _decode_swirl),
0xa681d655: ('start_mask', _decode_start_mask),
0x930c911d: ('end_mask', _decode_end_mask),
0x5b7662ce: ('balloon_board', _decode_balloon_board),
0xc96ba94a: ('text_font_name', _decode_text_font_name),
0xf9e0d0fb: ('text_gradient_start_color', _decode_text_gradient_start_color),
0xe0417e89: ('text_gradient_end_color', _decode_text_gradient_end_color),
0xf2e13506: ('text_outline_color', _decode_text_outline_color),
0x9cd35d69: ('text_decrement_time', _decode_text_decrement_time),
0x7b497313: ('text_pos_x', _decode_text_pos_x),
0xb015a0b6: ('text_pos_y', _decode_text_pos_y),
0xed3bba6: ('model_camera_pos', _decode_model_camera_pos),
0x68a22c5f: ('model_look_at_pos', _decode_model_look_at_pos),
0xf96e96a8: ('balloon_start_pos', _decode_balloon_start_pos),
0xb635e8b7: ('super_guide_dk_start_pos', _decode_super_guide_dk_start_pos),
0x6a69aa8c: ('super_guide_anim_delay', _decode_super_guide_anim_delay),
0x2dd09193: ('balloon_velocity', _decode_balloon_velocity),
0xbd5d2395: ('quit_button_position', _decode_quit_button_position),
0x921b9cdc: ('game_over_text_pos', _decode_game_over_text_pos),
0x92be12e9: ('button_text_locator', _decode_button_text_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DeathTikiTransition.py | 0.623492 | 0.302984 | DeathTikiTransition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.DamageEffectData import DamageEffectData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct291(BaseProperty):
unknown_0x0063bdc5: float = dataclasses.field(default=3.4000000953674316)
unknown_0xfa8948cc: float = dataclasses.field(default=0.5)
unknown_0xce1bcfd8: float = dataclasses.field(default=1.0)
unknown_0x96ecf959: float = dataclasses.field(default=0.5)
shock_wave_ring_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
damage_effect_data_0xae342f0f: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
damage_effect_data_0x46d65682: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x00c\xbd\xc5') # 0x63bdc5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0063bdc5))
data.write(b'\xfa\x89H\xcc') # 0xfa8948cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfa8948cc))
data.write(b'\xce\x1b\xcf\xd8') # 0xce1bcfd8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xce1bcfd8))
data.write(b'\x96\xec\xf9Y') # 0x96ecf959
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x96ecf959))
data.write(b'\xd3\xc19\x0e') # 0xd3c1390e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.shock_wave_ring_effect))
data.write(b'\xae4/\x0f') # 0xae342f0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect_data_0xae342f0f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'F\xd6V\x82') # 0x46d65682
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect_data_0x46d65682.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_0x0063bdc5=data['unknown_0x0063bdc5'],
unknown_0xfa8948cc=data['unknown_0xfa8948cc'],
unknown_0xce1bcfd8=data['unknown_0xce1bcfd8'],
unknown_0x96ecf959=data['unknown_0x96ecf959'],
shock_wave_ring_effect=data['shock_wave_ring_effect'],
damage_effect_data_0xae342f0f=DamageEffectData.from_json(data['damage_effect_data_0xae342f0f']),
damage_effect_data_0x46d65682=DamageEffectData.from_json(data['damage_effect_data_0x46d65682']),
)
def to_json(self) -> dict:
return {
'unknown_0x0063bdc5': self.unknown_0x0063bdc5,
'unknown_0xfa8948cc': self.unknown_0xfa8948cc,
'unknown_0xce1bcfd8': self.unknown_0xce1bcfd8,
'unknown_0x96ecf959': self.unknown_0x96ecf959,
'shock_wave_ring_effect': self.shock_wave_ring_effect,
'damage_effect_data_0xae342f0f': self.damage_effect_data_0xae342f0f.to_json(),
'damage_effect_data_0x46d65682': self.damage_effect_data_0x46d65682.to_json(),
}
def _decode_unknown_0x0063bdc5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfa8948cc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xce1bcfd8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x96ecf959(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shock_wave_ring_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_damage_effect_data_0xae342f0f(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
def _decode_damage_effect_data_0x46d65682(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x63bdc5: ('unknown_0x0063bdc5', _decode_unknown_0x0063bdc5),
0xfa8948cc: ('unknown_0xfa8948cc', _decode_unknown_0xfa8948cc),
0xce1bcfd8: ('unknown_0xce1bcfd8', _decode_unknown_0xce1bcfd8),
0x96ecf959: ('unknown_0x96ecf959', _decode_unknown_0x96ecf959),
0xd3c1390e: ('shock_wave_ring_effect', _decode_shock_wave_ring_effect),
0xae342f0f: ('damage_effect_data_0xae342f0f', _decode_damage_effect_data_0xae342f0f),
0x46d65682: ('damage_effect_data_0x46d65682', _decode_damage_effect_data_0x46d65682),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct291.py | 0.582016 | 0.283018 | UnknownStruct291.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.PlayerMovementParameters import PlayerMovementParameters
@dataclasses.dataclass()
class PlayerSplineAdvancementData(BaseProperty):
normal_movement_parameters: PlayerMovementParameters = dataclasses.field(default_factory=PlayerMovementParameters)
tar_inhibited_movement_parameters: PlayerMovementParameters = dataclasses.field(default_factory=PlayerMovementParameters)
programmatic_turn_speed: float = dataclasses.field(default=450.0)
has_air_control_damping: bool = dataclasses.field(default=False)
air_damping_time: float = dataclasses.field(default=4.0)
allow_turn_in_the_air: bool = dataclasses.field(default=True)
keep_jump_momentum: bool = dataclasses.field(default=True)
jump_control_scalar: float = dataclasses.field(default=2.0)
landing_damping_delay: float = dataclasses.field(default=0.07999999821186066)
after_jump_damping_time: float = dataclasses.field(default=0.20000000298023224)
after_jump_damping_amount: float = dataclasses.field(default=1.0)
use_push_ray: bool = dataclasses.field(default=False)
maximum_push_out_of_collision_speed: float = dataclasses.field(default=6.0)
ledge_stop_max_speed: float = dataclasses.field(default=3.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\x0e') # 14 properties
data.write(b'\xe2\x9b\xf3\x06') # 0xe29bf306
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal_movement_parameters.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xc8\xb0o') # 0xb0c8b06f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tar_inhibited_movement_parameters.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcf\x03\xcb\x0c') # 0xcf03cb0c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.programmatic_turn_speed))
data.write(b'\x03\x8e\xadS') # 0x38ead53
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.has_air_control_damping))
data.write(b'I\xa36i') # 0x49a33669
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_damping_time))
data.write(b'{\xf5\xcd\x04') # 0x7bf5cd04
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_turn_in_the_air))
data.write(b'g%\x9b#') # 0x67259b23
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.keep_jump_momentum))
data.write(b'B\xd7\x1aX') # 0x42d71a58
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_control_scalar))
data.write(b'_\xf22\x1f') # 0x5ff2321f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.landing_damping_delay))
data.write(b'\xaer\xa4\xff') # 0xae72a4ff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.after_jump_damping_time))
data.write(b'\xdeu2\xc0') # 0xde7532c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.after_jump_damping_amount))
data.write(b'o8\xb0-') # 0x6f38b02d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_push_ray))
data.write(b'y:\xb3V') # 0x793ab356
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_push_out_of_collision_speed))
data.write(b'IIL;') # 0x49494c3b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ledge_stop_max_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
normal_movement_parameters=PlayerMovementParameters.from_json(data['normal_movement_parameters']),
tar_inhibited_movement_parameters=PlayerMovementParameters.from_json(data['tar_inhibited_movement_parameters']),
programmatic_turn_speed=data['programmatic_turn_speed'],
has_air_control_damping=data['has_air_control_damping'],
air_damping_time=data['air_damping_time'],
allow_turn_in_the_air=data['allow_turn_in_the_air'],
keep_jump_momentum=data['keep_jump_momentum'],
jump_control_scalar=data['jump_control_scalar'],
landing_damping_delay=data['landing_damping_delay'],
after_jump_damping_time=data['after_jump_damping_time'],
after_jump_damping_amount=data['after_jump_damping_amount'],
use_push_ray=data['use_push_ray'],
maximum_push_out_of_collision_speed=data['maximum_push_out_of_collision_speed'],
ledge_stop_max_speed=data['ledge_stop_max_speed'],
)
def to_json(self) -> dict:
return {
'normal_movement_parameters': self.normal_movement_parameters.to_json(),
'tar_inhibited_movement_parameters': self.tar_inhibited_movement_parameters.to_json(),
'programmatic_turn_speed': self.programmatic_turn_speed,
'has_air_control_damping': self.has_air_control_damping,
'air_damping_time': self.air_damping_time,
'allow_turn_in_the_air': self.allow_turn_in_the_air,
'keep_jump_momentum': self.keep_jump_momentum,
'jump_control_scalar': self.jump_control_scalar,
'landing_damping_delay': self.landing_damping_delay,
'after_jump_damping_time': self.after_jump_damping_time,
'after_jump_damping_amount': self.after_jump_damping_amount,
'use_push_ray': self.use_push_ray,
'maximum_push_out_of_collision_speed': self.maximum_push_out_of_collision_speed,
'ledge_stop_max_speed': self.ledge_stop_max_speed,
}
def _decode_normal_movement_parameters(data: typing.BinaryIO, property_size: int):
return PlayerMovementParameters.from_stream(data, property_size)
def _decode_tar_inhibited_movement_parameters(data: typing.BinaryIO, property_size: int):
return PlayerMovementParameters.from_stream(data, property_size)
def _decode_programmatic_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_has_air_control_damping(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_air_damping_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_allow_turn_in_the_air(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_keep_jump_momentum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_jump_control_scalar(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_landing_damping_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_after_jump_damping_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_after_jump_damping_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_push_ray(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_maximum_push_out_of_collision_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ledge_stop_max_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]]] = {
0xe29bf306: ('normal_movement_parameters', _decode_normal_movement_parameters),
0xb0c8b06f: ('tar_inhibited_movement_parameters', _decode_tar_inhibited_movement_parameters),
0xcf03cb0c: ('programmatic_turn_speed', _decode_programmatic_turn_speed),
0x38ead53: ('has_air_control_damping', _decode_has_air_control_damping),
0x49a33669: ('air_damping_time', _decode_air_damping_time),
0x7bf5cd04: ('allow_turn_in_the_air', _decode_allow_turn_in_the_air),
0x67259b23: ('keep_jump_momentum', _decode_keep_jump_momentum),
0x42d71a58: ('jump_control_scalar', _decode_jump_control_scalar),
0x5ff2321f: ('landing_damping_delay', _decode_landing_damping_delay),
0xae72a4ff: ('after_jump_damping_time', _decode_after_jump_damping_time),
0xde7532c0: ('after_jump_damping_amount', _decode_after_jump_damping_amount),
0x6f38b02d: ('use_push_ray', _decode_use_push_ray),
0x793ab356: ('maximum_push_out_of_collision_speed', _decode_maximum_push_out_of_collision_speed),
0x49494c3b: ('ledge_stop_max_speed', _decode_ledge_stop_max_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerSplineAdvancementData.py | 0.686055 | 0.319732 | PlayerSplineAdvancementData.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 MoleCartStruct(BaseProperty):
spline_input: int = dataclasses.field(default=1306613276) # Choice
max_angle: float = dataclasses.field(default=45.0)
unknown_0x61dd3eb6: float = dataclasses.field(default=45.0)
fade_in_time: float = dataclasses.field(default=0.5)
sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x8a939379: Spline = dataclasses.field(default_factory=Spline)
pitch: Spline = dataclasses.field(default_factory=Spline)
volume: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'j\x06\xfa\xee') # 0x6a06faee
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.spline_input))
data.write(b'\xd9cU\x83') # 0xd9635583
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_angle))
data.write(b'a\xdd>\xb6') # 0x61dd3eb6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61dd3eb6))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'\xa5]\xac\xf6') # 0xa55dacf6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound))
data.write(b'\x8a\x93\x93y') # 0x8a939379
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x8a939379.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0er\x7f\xc4') # 0xe727fc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3\xfb\xe4\x84') # 0xf3fbe484
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
spline_input=data['spline_input'],
max_angle=data['max_angle'],
unknown_0x61dd3eb6=data['unknown_0x61dd3eb6'],
fade_in_time=data['fade_in_time'],
sound=data['sound'],
unknown_0x8a939379=Spline.from_json(data['unknown_0x8a939379']),
pitch=Spline.from_json(data['pitch']),
volume=Spline.from_json(data['volume']),
)
def to_json(self) -> dict:
return {
'spline_input': self.spline_input,
'max_angle': self.max_angle,
'unknown_0x61dd3eb6': self.unknown_0x61dd3eb6,
'fade_in_time': self.fade_in_time,
'sound': self.sound,
'unknown_0x8a939379': self.unknown_0x8a939379.to_json(),
'pitch': self.pitch.to_json(),
'volume': self.volume.to_json(),
}
def _decode_spline_input(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_max_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x61dd3eb6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x8a939379(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6a06faee: ('spline_input', _decode_spline_input),
0xd9635583: ('max_angle', _decode_max_angle),
0x61dd3eb6: ('unknown_0x61dd3eb6', _decode_unknown_0x61dd3eb6),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0xa55dacf6: ('sound', _decode_sound),
0x8a939379: ('unknown_0x8a939379', _decode_unknown_0x8a939379),
0xe727fc4: ('pitch', _decode_pitch),
0xf3fbe484: ('volume', _decode_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MoleCartStruct.py | 0.677687 | 0.274699 | MoleCartStruct.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 UnknownStruct91(BaseProperty):
world: bool = dataclasses.field(default=True)
primary: bool = dataclasses.field(default=True)
secondary: bool = dataclasses.field(default=True)
third: bool = dataclasses.field(default=True)
fourth: bool = dataclasses.field(default=True)
fifth: bool = dataclasses.field(default=True)
sixth: bool = dataclasses.field(default=True)
seventh: bool = dataclasses.field(default=True)
eighth: 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\t') # 9 properties
data.write(b'\x1a\xb8C\xd9') # 0x1ab843d9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.world))
data.write(b'Nx\xc4\xac') # 0x4e78c4ac
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.primary))
data.write(b'6\xcc"\xc2') # 0x36cc22c2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.secondary))
data.write(b'u\xf5\xdd\xda') # 0x75f5ddda
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.third))
data.write(b'\xdexj8') # 0xde786a38
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fourth))
data.write(b'\xde\x88\xc9F') # 0xde88c946
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fifth))
data.write(b'\x0f>)\xeb') # 0xf3e29eb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sixth))
data.write(b'\xcf\xe5\x83\xef') # 0xcfe583ef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.seventh))
data.write(b'\xbbe]g') # 0xbb655d67
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.eighth))
@classmethod
def from_json(cls, data: dict):
return cls(
world=data['world'],
primary=data['primary'],
secondary=data['secondary'],
third=data['third'],
fourth=data['fourth'],
fifth=data['fifth'],
sixth=data['sixth'],
seventh=data['seventh'],
eighth=data['eighth'],
)
def to_json(self) -> dict:
return {
'world': self.world,
'primary': self.primary,
'secondary': self.secondary,
'third': self.third,
'fourth': self.fourth,
'fifth': self.fifth,
'sixth': self.sixth,
'seventh': self.seventh,
'eighth': self.eighth,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1ab843d9, 0x4e78c4ac, 0x36cc22c2, 0x75f5ddda, 0xde786a38, 0xde88c946, 0xf3e29eb, 0xcfe583ef, 0xbb655d67)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct91]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(63))
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 UnknownStruct91(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_world(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_primary(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_secondary(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_third(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fourth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fifth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sixth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_seventh(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_eighth(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]]] = {
0x1ab843d9: ('world', _decode_world),
0x4e78c4ac: ('primary', _decode_primary),
0x36cc22c2: ('secondary', _decode_secondary),
0x75f5ddda: ('third', _decode_third),
0xde786a38: ('fourth', _decode_fourth),
0xde88c946: ('fifth', _decode_fifth),
0xf3e29eb: ('sixth', _decode_sixth),
0xcfe583ef: ('seventh', _decode_seventh),
0xbb655d67: ('eighth', _decode_eighth),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct91.py | 0.602997 | 0.361052 | UnknownStruct91.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.UnknownStruct158 import UnknownStruct158
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 UnknownStruct159(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct26_0xf0f0840b: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x3397f5e0: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x95833e87: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
strg_0x518dd3da: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0xd374144c: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x6a89715b: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct158: UnknownStruct158 = dataclasses.field(default_factory=UnknownStruct158)
@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'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b'\xf0\xf0\x84\x0b') # 0xf0f0840b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0xf0f0840b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x97\xf5\xe0') # 0x3397f5e0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x3397f5e0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\x83>\x87') # 0x95833e87
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x95833e87.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\x8d\xd3\xda') # 0x518dd3da
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x518dd3da))
data.write(b'\xd3t\x14L') # 0xd374144c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0xd374144c))
data.write(b'j\x89q[') # 0x6a89715b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x6a89715b))
data.write(b'R6?\xb6') # 0x52363fb6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct158.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(
gui_frame=data['gui_frame'],
unknown_struct26_0xf0f0840b=UnknownStruct26.from_json(data['unknown_struct26_0xf0f0840b']),
unknown_struct26_0x3397f5e0=UnknownStruct26.from_json(data['unknown_struct26_0x3397f5e0']),
unknown_struct26_0x95833e87=UnknownStruct26.from_json(data['unknown_struct26_0x95833e87']),
strg_0x518dd3da=data['strg_0x518dd3da'],
strg_0xd374144c=data['strg_0xd374144c'],
strg_0x6a89715b=data['strg_0x6a89715b'],
unknown_struct158=UnknownStruct158.from_json(data['unknown_struct158']),
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_struct26_0xf0f0840b': self.unknown_struct26_0xf0f0840b.to_json(),
'unknown_struct26_0x3397f5e0': self.unknown_struct26_0x3397f5e0.to_json(),
'unknown_struct26_0x95833e87': self.unknown_struct26_0x95833e87.to_json(),
'strg_0x518dd3da': self.strg_0x518dd3da,
'strg_0xd374144c': self.strg_0xd374144c,
'strg_0x6a89715b': self.strg_0x6a89715b,
'unknown_struct158': self.unknown_struct158.to_json(),
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct26_0xf0f0840b(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x3397f5e0(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x95833e87(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_strg_0x518dd3da(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0xd374144c(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x6a89715b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct158(data: typing.BinaryIO, property_size: int):
return UnknownStruct158.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0xf0f0840b: ('unknown_struct26_0xf0f0840b', _decode_unknown_struct26_0xf0f0840b),
0x3397f5e0: ('unknown_struct26_0x3397f5e0', _decode_unknown_struct26_0x3397f5e0),
0x95833e87: ('unknown_struct26_0x95833e87', _decode_unknown_struct26_0x95833e87),
0x518dd3da: ('strg_0x518dd3da', _decode_strg_0x518dd3da),
0xd374144c: ('strg_0xd374144c', _decode_strg_0xd374144c),
0x6a89715b: ('strg_0x6a89715b', _decode_strg_0x6a89715b),
0x52363fb6: ('unknown_struct158', _decode_unknown_struct158),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct159.py | 0.55929 | 0.225246 | UnknownStruct159.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 UnknownStruct281(BaseProperty):
unknown_0x8a58a7f8: int = dataclasses.field(default=1)
unknown_0x72d0dc87: float = dataclasses.field(default=30.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'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'r\xd0\xdc\x87') # 0x72d0dc87
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72d0dc87))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
unknown_0x72d0dc87=data['unknown_0x72d0dc87'],
)
def to_json(self) -> dict:
return {
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'unknown_0x72d0dc87': self.unknown_0x72d0dc87,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8a58a7f8, 0x72d0dc87)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct281]:
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 UnknownStruct281(
dec[2],
dec[5],
)
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x72d0dc87(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0x72d0dc87: ('unknown_0x72d0dc87', _decode_unknown_0x72d0dc87),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct281.py | 0.612889 | 0.276716 | UnknownStruct281.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 UnknownStruct282(BaseProperty):
unknown_0x968337ab: int = dataclasses.field(default=3)
unknown_0x8308e359: int = dataclasses.field(default=5)
unknown_0x9b4f1416: 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\x03') # 3 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))
data.write(b'\x9bO\x14\x16') # 0x9b4f1416
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9b4f1416))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x968337ab=data['unknown_0x968337ab'],
unknown_0x8308e359=data['unknown_0x8308e359'],
unknown_0x9b4f1416=data['unknown_0x9b4f1416'],
)
def to_json(self) -> dict:
return {
'unknown_0x968337ab': self.unknown_0x968337ab,
'unknown_0x8308e359': self.unknown_0x8308e359,
'unknown_0x9b4f1416': self.unknown_0x9b4f1416,
}
_FAST_FORMAT = None
_FAST_IDS = (0x968337ab, 0x8308e359, 0x9b4f1416)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct282]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHf')
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 UnknownStruct282(
dec[2],
dec[5],
dec[8],
)
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_0x9b4f1416(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]]] = {
0x968337ab: ('unknown_0x968337ab', _decode_unknown_0x968337ab),
0x8308e359: ('unknown_0x8308e359', _decode_unknown_0x8308e359),
0x9b4f1416: ('unknown_0x9b4f1416', _decode_unknown_0x9b4f1416),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct282.py | 0.611614 | 0.290921 | UnknownStruct282.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 PlayerShieldSplineData(BaseProperty):
health_equal_or_greater_than: int = dataclasses.field(default=10)
shield_visual_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'9\xe3`L') # 0x39e3604c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.health_equal_or_greater_than))
data.write(b'\xfe\x8f\x08\x86') # 0xfe8f0886
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shield_visual_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
health_equal_or_greater_than=data['health_equal_or_greater_than'],
shield_visual_spline=Spline.from_json(data['shield_visual_spline']),
)
def to_json(self) -> dict:
return {
'health_equal_or_greater_than': self.health_equal_or_greater_than,
'shield_visual_spline': self.shield_visual_spline.to_json(),
}
def _decode_health_equal_or_greater_than(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_shield_visual_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x39e3604c: ('health_equal_or_greater_than', _decode_health_equal_or_greater_than),
0xfe8f0886: ('shield_visual_spline', _decode_shield_visual_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerShieldSplineData.py | 0.672654 | 0.303138 | PlayerShieldSplineData.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.GenericCreatureStructD import GenericCreatureStructD
@dataclasses.dataclass()
class Groups(BaseProperty):
number_of_groups: int = dataclasses.field(default=0)
group01: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group02: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group03: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group04: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group05: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group06: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group07: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
group08: GenericCreatureStructD = dataclasses.field(default_factory=GenericCreatureStructD)
@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'\x07\xf5\xda?') # 0x7f5da3f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_groups))
data.write(b'iT\xc4\xa6') # 0x6954c4a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group01.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)^') # 0x9b03295e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group02.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|\x1e\x8f\xc9') # 0x7c1e8fc9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group03.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xdd\xf4\xef') # 0xa4ddf4ef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group04.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\xc0Rx') # 0x43c05278
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb1\x97\xbf\x80') # 0xb197bf80
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group06.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\x8a\x19\x17') # 0x568a1917
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group07.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdb`O\x8d') # 0xdb604f8d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.group08.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
number_of_groups=data['number_of_groups'],
group01=GenericCreatureStructD.from_json(data['group01']),
group02=GenericCreatureStructD.from_json(data['group02']),
group03=GenericCreatureStructD.from_json(data['group03']),
group04=GenericCreatureStructD.from_json(data['group04']),
group05=GenericCreatureStructD.from_json(data['group05']),
group06=GenericCreatureStructD.from_json(data['group06']),
group07=GenericCreatureStructD.from_json(data['group07']),
group08=GenericCreatureStructD.from_json(data['group08']),
)
def to_json(self) -> dict:
return {
'number_of_groups': self.number_of_groups,
'group01': self.group01.to_json(),
'group02': self.group02.to_json(),
'group03': self.group03.to_json(),
'group04': self.group04.to_json(),
'group05': self.group05.to_json(),
'group06': self.group06.to_json(),
'group07': self.group07.to_json(),
'group08': self.group08.to_json(),
}
def _decode_number_of_groups(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_group01(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group02(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group03(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group04(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group05(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group06(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group07(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
def _decode_group08(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructD.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7f5da3f: ('number_of_groups', _decode_number_of_groups),
0x6954c4a6: ('group01', _decode_group01),
0x9b03295e: ('group02', _decode_group02),
0x7c1e8fc9: ('group03', _decode_group03),
0xa4ddf4ef: ('group04', _decode_group04),
0x43c05278: ('group05', _decode_group05),
0xb197bf80: ('group06', _decode_group06),
0x568a1917: ('group07', _decode_group07),
0xdb604f8d: ('group08', _decode_group08),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/Groups.py | 0.547948 | 0.348008 | Groups.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 ForestBossStructA(BaseProperty):
sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown: Spline = dataclasses.field(default_factory=Spline)
pitch: Spline = dataclasses.field(default_factory=Spline)
volume: Spline = dataclasses.field(default_factory=Spline)
maximum_input_value: float = dataclasses.field(default=15.0)
minimum_input_value: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xa5]\xac\xf6') # 0xa55dacf6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound))
data.write(b'\x8a\x93\x93y') # 0x8a939379
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0er\x7f\xc4') # 0xe727fc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3\xfb\xe4\x84') # 0xf3fbe484
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2\x974\x05') # 0xe2973405
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_input_value))
data.write(b'\xa3\x80\x0b\x83') # 0xa3800b83
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_input_value))
@classmethod
def from_json(cls, data: dict):
return cls(
sound=data['sound'],
unknown=Spline.from_json(data['unknown']),
pitch=Spline.from_json(data['pitch']),
volume=Spline.from_json(data['volume']),
maximum_input_value=data['maximum_input_value'],
minimum_input_value=data['minimum_input_value'],
)
def to_json(self) -> dict:
return {
'sound': self.sound,
'unknown': self.unknown.to_json(),
'pitch': self.pitch.to_json(),
'volume': self.volume.to_json(),
'maximum_input_value': self.maximum_input_value,
'minimum_input_value': self.minimum_input_value,
}
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_maximum_input_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_input_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]]] = {
0xa55dacf6: ('sound', _decode_sound),
0x8a939379: ('unknown', _decode_unknown),
0xe727fc4: ('pitch', _decode_pitch),
0xf3fbe484: ('volume', _decode_volume),
0xe2973405: ('maximum_input_value', _decode_maximum_input_value),
0xa3800b83: ('minimum_input_value', _decode_minimum_input_value),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ForestBossStructA.py | 0.753376 | 0.274113 | ForestBossStructA.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 UnknownStruct234(BaseProperty):
unknown_0xe578efc6: int = dataclasses.field(default=2)
unknown_0x418f204d: 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]
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'\xe5x\xef\xc6') # 0xe578efc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe578efc6))
data.write(b'A\x8f M') # 0x418f204d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x418f204d))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xe578efc6=data['unknown_0xe578efc6'],
unknown_0x418f204d=data['unknown_0x418f204d'],
)
def to_json(self) -> dict:
return {
'unknown_0xe578efc6': self.unknown_0xe578efc6,
'unknown_0x418f204d': self.unknown_0x418f204d,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe578efc6, 0x418f204d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct234]:
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 UnknownStruct234(
dec[2],
dec[5],
)
def _decode_unknown_0xe578efc6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x418f204d(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]]] = {
0xe578efc6: ('unknown_0xe578efc6', _decode_unknown_0xe578efc6),
0x418f204d: ('unknown_0x418f204d', _decode_unknown_0x418f204d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct234.py | 0.635449 | 0.274119 | UnknownStruct234.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.UnknownStruct51 import UnknownStruct51
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct60 import UnknownStruct60
@dataclasses.dataclass()
class RobotChickenFlyerStructB(BaseProperty):
attack_type: enums.AttackType = dataclasses.field(default=enums.AttackType.Unknown1)
unknown_0x8a58a7f8: int = dataclasses.field(default=3)
unknown_0x584b5df1: UnknownStruct60 = dataclasses.field(default_factory=UnknownStruct60)
unknown_struct51_0x1d366d8e: UnknownStruct51 = dataclasses.field(default_factory=UnknownStruct51)
unknown_struct51_0x525191c2: UnknownStruct51 = dataclasses.field(default_factory=UnknownStruct51)
unknown_struct51_0x1b80811c: UnknownStruct51 = dataclasses.field(default_factory=UnknownStruct51)
unknown_struct51_0xed21c295: UnknownStruct51 = dataclasses.field(default_factory=UnknownStruct51)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x07\xd99\xa1') # 0x7d939a1
data.write(b'\x00\x04') # size
self.attack_type.to_stream(data)
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'XK]\xf1') # 0x584b5df1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x584b5df1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d6m\x8e') # 0x1d366d8e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct51_0x1d366d8e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'RQ\x91\xc2') # 0x525191c2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct51_0x525191c2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b\x80\x81\x1c') # 0x1b80811c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct51_0x1b80811c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed!\xc2\x95') # 0xed21c295
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct51_0xed21c295.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_0x8a58a7f8=data['unknown_0x8a58a7f8'],
unknown_0x584b5df1=UnknownStruct60.from_json(data['unknown_0x584b5df1']),
unknown_struct51_0x1d366d8e=UnknownStruct51.from_json(data['unknown_struct51_0x1d366d8e']),
unknown_struct51_0x525191c2=UnknownStruct51.from_json(data['unknown_struct51_0x525191c2']),
unknown_struct51_0x1b80811c=UnknownStruct51.from_json(data['unknown_struct51_0x1b80811c']),
unknown_struct51_0xed21c295=UnknownStruct51.from_json(data['unknown_struct51_0xed21c295']),
)
def to_json(self) -> dict:
return {
'attack_type': self.attack_type.to_json(),
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'unknown_0x584b5df1': self.unknown_0x584b5df1.to_json(),
'unknown_struct51_0x1d366d8e': self.unknown_struct51_0x1d366d8e.to_json(),
'unknown_struct51_0x525191c2': self.unknown_struct51_0x525191c2.to_json(),
'unknown_struct51_0x1b80811c': self.unknown_struct51_0x1b80811c.to_json(),
'unknown_struct51_0xed21c295': self.unknown_struct51_0xed21c295.to_json(),
}
def _decode_attack_type(data: typing.BinaryIO, property_size: int):
return enums.AttackType.from_stream(data)
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x584b5df1(data: typing.BinaryIO, property_size: int):
return UnknownStruct60.from_stream(data, property_size)
def _decode_unknown_struct51_0x1d366d8e(data: typing.BinaryIO, property_size: int):
return UnknownStruct51.from_stream(data, property_size)
def _decode_unknown_struct51_0x525191c2(data: typing.BinaryIO, property_size: int):
return UnknownStruct51.from_stream(data, property_size)
def _decode_unknown_struct51_0x1b80811c(data: typing.BinaryIO, property_size: int):
return UnknownStruct51.from_stream(data, property_size)
def _decode_unknown_struct51_0xed21c295(data: typing.BinaryIO, property_size: int):
return UnknownStruct51.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),
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0x584b5df1: ('unknown_0x584b5df1', _decode_unknown_0x584b5df1),
0x1d366d8e: ('unknown_struct51_0x1d366d8e', _decode_unknown_struct51_0x1d366d8e),
0x525191c2: ('unknown_struct51_0x525191c2', _decode_unknown_struct51_0x525191c2),
0x1b80811c: ('unknown_struct51_0x1b80811c', _decode_unknown_struct51_0x1b80811c),
0xed21c295: ('unknown_struct51_0xed21c295', _decode_unknown_struct51_0xed21c295),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RobotChickenFlyerStructB.py | 0.562777 | 0.287318 | RobotChickenFlyerStructB.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
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct193 import UnknownStruct193
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 ProjectileData(BaseProperty):
max_lifetime: float = dataclasses.field(default=30.0)
unknown_0x9cbc24b1: bool = dataclasses.field(default=False)
unknown_0x7e2ea16c: bool = dataclasses.field(default=False)
explosion_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0xebefb1a9: bool = dataclasses.field(default=False)
use_alternate_damage_effect: bool = dataclasses.field(default=False)
launch_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
crash_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
flight_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x05c67d0b: bool = dataclasses.field(default=False)
launch_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
crash_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
flight_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
orientation: enums.Orientation = dataclasses.field(default=enums.Orientation.Unknown1)
unknown_0xa17c618d: bool = dataclasses.field(default=False)
unknown_0x469f8fb8: bool = dataclasses.field(default=False)
constant_rotation: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_struct193: UnknownStruct193 = dataclasses.field(default_factory=UnknownStruct193)
@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'\xd4\xd4\xed\xfa') # 0xd4d4edfa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_lifetime))
data.write(b'\x9c\xbc$\xb1') # 0x9cbc24b1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x9cbc24b1))
data.write(b'~.\xa1l') # 0x7e2ea16c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7e2ea16c))
data.write(b'\xde\xfft\xea') # 0xdeff74ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.explosion_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xef\xb1\xa9') # 0xebefb1a9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xebefb1a9))
data.write(b'\xf0\x99;\xfe') # 0xf0993bfe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_alternate_damage_effect))
data.write(b'\xa4i.\x9c') # 0xa4692e9c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.launch_effect))
data.write(b'\xa0n\xda\xf9') # 0xa06edaf9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crash_effect))
data.write(b'\xde\x15e\xa9') # 0xde1565a9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flight_effect))
data.write(b'\x05\xc6}\x0b') # 0x5c67d0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x05c67d0b))
data.write(b'\xf7\xf7\xf6\xaf') # 0xf7f7f6af
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.launch_sound))
data.write(b'+%\x86)') # 0x2b258629
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crash_sound))
data.write(b'\xe1\xe6k$') # 0xe1e66b24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flight_sound))
data.write(b'\xf4\xbff7') # 0xf4bf6637
data.write(b'\x00\x04') # size
self.orientation.to_stream(data)
data.write(b'\xa1|a\x8d') # 0xa17c618d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa17c618d))
data.write(b'F\x9f\x8f\xb8') # 0x469f8fb8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x469f8fb8))
data.write(b'\xec\x08(\xce') # 0xec0828ce
data.write(b'\x00\x0c') # size
self.constant_rotation.to_stream(data)
data.write(b'\x01\x83\xdcq') # 0x183dc71
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct193.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(
max_lifetime=data['max_lifetime'],
unknown_0x9cbc24b1=data['unknown_0x9cbc24b1'],
unknown_0x7e2ea16c=data['unknown_0x7e2ea16c'],
explosion_damage=DamageInfo.from_json(data['explosion_damage']),
unknown_0xebefb1a9=data['unknown_0xebefb1a9'],
use_alternate_damage_effect=data['use_alternate_damage_effect'],
launch_effect=data['launch_effect'],
crash_effect=data['crash_effect'],
flight_effect=data['flight_effect'],
unknown_0x05c67d0b=data['unknown_0x05c67d0b'],
launch_sound=data['launch_sound'],
crash_sound=data['crash_sound'],
flight_sound=data['flight_sound'],
orientation=enums.Orientation.from_json(data['orientation']),
unknown_0xa17c618d=data['unknown_0xa17c618d'],
unknown_0x469f8fb8=data['unknown_0x469f8fb8'],
constant_rotation=Vector.from_json(data['constant_rotation']),
unknown_struct193=UnknownStruct193.from_json(data['unknown_struct193']),
)
def to_json(self) -> dict:
return {
'max_lifetime': self.max_lifetime,
'unknown_0x9cbc24b1': self.unknown_0x9cbc24b1,
'unknown_0x7e2ea16c': self.unknown_0x7e2ea16c,
'explosion_damage': self.explosion_damage.to_json(),
'unknown_0xebefb1a9': self.unknown_0xebefb1a9,
'use_alternate_damage_effect': self.use_alternate_damage_effect,
'launch_effect': self.launch_effect,
'crash_effect': self.crash_effect,
'flight_effect': self.flight_effect,
'unknown_0x05c67d0b': self.unknown_0x05c67d0b,
'launch_sound': self.launch_sound,
'crash_sound': self.crash_sound,
'flight_sound': self.flight_sound,
'orientation': self.orientation.to_json(),
'unknown_0xa17c618d': self.unknown_0xa17c618d,
'unknown_0x469f8fb8': self.unknown_0x469f8fb8,
'constant_rotation': self.constant_rotation.to_json(),
'unknown_struct193': self.unknown_struct193.to_json(),
}
def _decode_max_lifetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9cbc24b1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7e2ea16c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explosion_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown_0xebefb1a9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_alternate_damage_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_launch_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_crash_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flight_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x05c67d0b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_launch_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_crash_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flight_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_orientation(data: typing.BinaryIO, property_size: int):
return enums.Orientation.from_stream(data)
def _decode_unknown_0xa17c618d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x469f8fb8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_constant_rotation(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_struct193(data: typing.BinaryIO, property_size: int):
return UnknownStruct193.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd4d4edfa: ('max_lifetime', _decode_max_lifetime),
0x9cbc24b1: ('unknown_0x9cbc24b1', _decode_unknown_0x9cbc24b1),
0x7e2ea16c: ('unknown_0x7e2ea16c', _decode_unknown_0x7e2ea16c),
0xdeff74ea: ('explosion_damage', _decode_explosion_damage),
0xebefb1a9: ('unknown_0xebefb1a9', _decode_unknown_0xebefb1a9),
0xf0993bfe: ('use_alternate_damage_effect', _decode_use_alternate_damage_effect),
0xa4692e9c: ('launch_effect', _decode_launch_effect),
0xa06edaf9: ('crash_effect', _decode_crash_effect),
0xde1565a9: ('flight_effect', _decode_flight_effect),
0x5c67d0b: ('unknown_0x05c67d0b', _decode_unknown_0x05c67d0b),
0xf7f7f6af: ('launch_sound', _decode_launch_sound),
0x2b258629: ('crash_sound', _decode_crash_sound),
0xe1e66b24: ('flight_sound', _decode_flight_sound),
0xf4bf6637: ('orientation', _decode_orientation),
0xa17c618d: ('unknown_0xa17c618d', _decode_unknown_0xa17c618d),
0x469f8fb8: ('unknown_0x469f8fb8', _decode_unknown_0x469f8fb8),
0xec0828ce: ('constant_rotation', _decode_constant_rotation),
0x183dc71: ('unknown_struct193', _decode_unknown_struct193),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileData.py | 0.556038 | 0.232277 | ProjectileData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class PickupData(BaseProperty):
item_to_give: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.Banana)
capacity_increase: int = dataclasses.field(default=1)
item_percentage_increase: int = dataclasses.field(default=0)
amount: int = dataclasses.field(default=1)
unknown_0x39262bce: int = dataclasses.field(default=1)
respawn_time: float = dataclasses.field(default=0.0)
lifetime: float = dataclasses.field(default=0.0)
fadetime: float = dataclasses.field(default=0.0)
fade_out_time: float = dataclasses.field(default=2.0)
activation_delay: float = dataclasses.field(default=0.0)
unknown_0x059fefc5: float = dataclasses.field(default=0.25)
flying_pickup_speed: float = dataclasses.field(default=3.0)
flying_pickup_target_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
flying_pickup_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
flying_pickup_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
pickup_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
touched_sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xdb5b110d: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x5dcf63a3: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x9693b006: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
ghost_touched_sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x2cf86398: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x93d41865: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x15406acb: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xde1cb96e: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
texture_set: int = dataclasses.field(default=0)
auto_spin: bool = dataclasses.field(default=False)
blink_out: bool = dataclasses.field(default=False)
unknown_0x69539dfc: bool = dataclasses.field(default=True)
can_render_sort: bool = dataclasses.field(default=True)
unknown_0x4ddc1327: bool = dataclasses.field(default=False)
render_in_foreground: bool = dataclasses.field(default=False)
pickup_delay: float = dataclasses.field(default=0.0)
unknown_0xe722238d: bool = dataclasses.field(default=True)
unknown_0xfc7cfe9b: bool = dataclasses.field(default=True)
unknown_0xea3675c5: 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%') # 37 properties
data.write(b'\xa0.\xf0\xc4') # 0xa02ef0c4
data.write(b'\x00\x04') # size
self.item_to_give.to_stream(data)
data.write(b'(\xc7\x1bT') # 0x28c71b54
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.capacity_increase))
data.write(b'\x16Z\xb0i') # 0x165ab069
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.item_percentage_increase))
data.write(b'\x94\xaf\x14E') # 0x94af1445
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.amount))
data.write(b'9&+\xce') # 0x39262bce
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x39262bce))
data.write(b'\xf7\xfb\xaa\xa5') # 0xf7fbaaa5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.respawn_time))
data.write(b'2\xdcg\xf6') # 0x32dc67f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lifetime))
data.write(b'V\xe3\xce\xef') # 0x56e3ceef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fadetime))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\xe5\x85\xf1f') # 0xe585f166
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.activation_delay))
data.write(b'\x05\x9f\xef\xc5') # 0x59fefc5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x059fefc5))
data.write(b'L\xd44:') # 0x4cd4343a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flying_pickup_speed))
data.write(b'/TV\xa7') # 0x2f5456a7
data.write(b'\x00\x0c') # size
self.flying_pickup_target_scale.to_stream(data)
data.write(b'\xed9\x8e\xfb') # 0xed398efb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flying_pickup_model))
data.write(b'\xe1\xcb\x9e\xc7') # 0xe1cb9ec7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flying_pickup_effect))
data.write(b'\xa9\xfe\x87*') # 0xa9fe872a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.pickup_effect))
data.write(b'7\x1c\xd74') # 0x371cd734
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.touched_sound_effect))
data.write(b'\xaa\x12_\x90') # 0xaa125f90
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud))
data.write(b'\xdb[\x11\r') # 0xdb5b110d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xdb5b110d))
data.write(b']\xcfc\xa3') # 0x5dcf63a3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x5dcf63a3))
data.write(b'\x96\x93\xb0\x06') # 0x9693b006
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x9693b006))
data.write(b'\x1e\t;\x02') # 0x1e093b02
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ghost_touched_sound_effect))
data.write(b',\xf8c\x98') # 0x2cf86398
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x2cf86398))
data.write(b'\x93\xd4\x18e') # 0x93d41865
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x93d41865))
data.write(b'\x15@j\xcb') # 0x15406acb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x15406acb))
data.write(b'\xde\x1c\xb9n') # 0xde1cb96e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xde1cb96e))
data.write(b'k@\xac\xef') # 0x6b40acef
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.texture_set))
data.write(b'\x96\x1c\r\x17') # 0x961c0d17
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_spin))
data.write(b'\xa7U\xeb\x02') # 0xa755eb02
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.blink_out))
data.write(b'iS\x9d\xfc') # 0x69539dfc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x69539dfc))
data.write(b'\x85\xce\xa2f') # 0x85cea266
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_render_sort))
data.write(b"M\xdc\x13'") # 0x4ddc1327
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4ddc1327))
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'\xbc\x96!O') # 0xbc96214f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pickup_delay))
data.write(b'\xe7"#\x8d') # 0xe722238d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe722238d))
data.write(b'\xfc|\xfe\x9b') # 0xfc7cfe9b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xfc7cfe9b))
data.write(b'\xea6u\xc5') # 0xea3675c5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xea3675c5))
@classmethod
def from_json(cls, data: dict):
return cls(
item_to_give=enums.PlayerItem.from_json(data['item_to_give']),
capacity_increase=data['capacity_increase'],
item_percentage_increase=data['item_percentage_increase'],
amount=data['amount'],
unknown_0x39262bce=data['unknown_0x39262bce'],
respawn_time=data['respawn_time'],
lifetime=data['lifetime'],
fadetime=data['fadetime'],
fade_out_time=data['fade_out_time'],
activation_delay=data['activation_delay'],
unknown_0x059fefc5=data['unknown_0x059fefc5'],
flying_pickup_speed=data['flying_pickup_speed'],
flying_pickup_target_scale=Vector.from_json(data['flying_pickup_target_scale']),
flying_pickup_model=data['flying_pickup_model'],
flying_pickup_effect=data['flying_pickup_effect'],
pickup_effect=data['pickup_effect'],
touched_sound_effect=data['touched_sound_effect'],
caud=data['caud'],
unknown_0xdb5b110d=data['unknown_0xdb5b110d'],
unknown_0x5dcf63a3=data['unknown_0x5dcf63a3'],
unknown_0x9693b006=data['unknown_0x9693b006'],
ghost_touched_sound_effect=data['ghost_touched_sound_effect'],
unknown_0x2cf86398=data['unknown_0x2cf86398'],
unknown_0x93d41865=data['unknown_0x93d41865'],
unknown_0x15406acb=data['unknown_0x15406acb'],
unknown_0xde1cb96e=data['unknown_0xde1cb96e'],
texture_set=data['texture_set'],
auto_spin=data['auto_spin'],
blink_out=data['blink_out'],
unknown_0x69539dfc=data['unknown_0x69539dfc'],
can_render_sort=data['can_render_sort'],
unknown_0x4ddc1327=data['unknown_0x4ddc1327'],
render_in_foreground=data['render_in_foreground'],
pickup_delay=data['pickup_delay'],
unknown_0xe722238d=data['unknown_0xe722238d'],
unknown_0xfc7cfe9b=data['unknown_0xfc7cfe9b'],
unknown_0xea3675c5=data['unknown_0xea3675c5'],
)
def to_json(self) -> dict:
return {
'item_to_give': self.item_to_give.to_json(),
'capacity_increase': self.capacity_increase,
'item_percentage_increase': self.item_percentage_increase,
'amount': self.amount,
'unknown_0x39262bce': self.unknown_0x39262bce,
'respawn_time': self.respawn_time,
'lifetime': self.lifetime,
'fadetime': self.fadetime,
'fade_out_time': self.fade_out_time,
'activation_delay': self.activation_delay,
'unknown_0x059fefc5': self.unknown_0x059fefc5,
'flying_pickup_speed': self.flying_pickup_speed,
'flying_pickup_target_scale': self.flying_pickup_target_scale.to_json(),
'flying_pickup_model': self.flying_pickup_model,
'flying_pickup_effect': self.flying_pickup_effect,
'pickup_effect': self.pickup_effect,
'touched_sound_effect': self.touched_sound_effect,
'caud': self.caud,
'unknown_0xdb5b110d': self.unknown_0xdb5b110d,
'unknown_0x5dcf63a3': self.unknown_0x5dcf63a3,
'unknown_0x9693b006': self.unknown_0x9693b006,
'ghost_touched_sound_effect': self.ghost_touched_sound_effect,
'unknown_0x2cf86398': self.unknown_0x2cf86398,
'unknown_0x93d41865': self.unknown_0x93d41865,
'unknown_0x15406acb': self.unknown_0x15406acb,
'unknown_0xde1cb96e': self.unknown_0xde1cb96e,
'texture_set': self.texture_set,
'auto_spin': self.auto_spin,
'blink_out': self.blink_out,
'unknown_0x69539dfc': self.unknown_0x69539dfc,
'can_render_sort': self.can_render_sort,
'unknown_0x4ddc1327': self.unknown_0x4ddc1327,
'render_in_foreground': self.render_in_foreground,
'pickup_delay': self.pickup_delay,
'unknown_0xe722238d': self.unknown_0xe722238d,
'unknown_0xfc7cfe9b': self.unknown_0xfc7cfe9b,
'unknown_0xea3675c5': self.unknown_0xea3675c5,
}
def _decode_item_to_give(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_capacity_increase(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_item_percentage_increase(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x39262bce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_respawn_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lifetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fadetime(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_activation_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x059fefc5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flying_pickup_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flying_pickup_target_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_flying_pickup_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flying_pickup_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_pickup_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_touched_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xdb5b110d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x5dcf63a3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x9693b006(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ghost_touched_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x2cf86398(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x93d41865(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x15406acb(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xde1cb96e(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_auto_spin(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_blink_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x69539dfc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_render_sort(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4ddc1327(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_pickup_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe722238d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xfc7cfe9b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xea3675c5(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]]] = {
0xa02ef0c4: ('item_to_give', _decode_item_to_give),
0x28c71b54: ('capacity_increase', _decode_capacity_increase),
0x165ab069: ('item_percentage_increase', _decode_item_percentage_increase),
0x94af1445: ('amount', _decode_amount),
0x39262bce: ('unknown_0x39262bce', _decode_unknown_0x39262bce),
0xf7fbaaa5: ('respawn_time', _decode_respawn_time),
0x32dc67f6: ('lifetime', _decode_lifetime),
0x56e3ceef: ('fadetime', _decode_fadetime),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0xe585f166: ('activation_delay', _decode_activation_delay),
0x59fefc5: ('unknown_0x059fefc5', _decode_unknown_0x059fefc5),
0x4cd4343a: ('flying_pickup_speed', _decode_flying_pickup_speed),
0x2f5456a7: ('flying_pickup_target_scale', _decode_flying_pickup_target_scale),
0xed398efb: ('flying_pickup_model', _decode_flying_pickup_model),
0xe1cb9ec7: ('flying_pickup_effect', _decode_flying_pickup_effect),
0xa9fe872a: ('pickup_effect', _decode_pickup_effect),
0x371cd734: ('touched_sound_effect', _decode_touched_sound_effect),
0xaa125f90: ('caud', _decode_caud),
0xdb5b110d: ('unknown_0xdb5b110d', _decode_unknown_0xdb5b110d),
0x5dcf63a3: ('unknown_0x5dcf63a3', _decode_unknown_0x5dcf63a3),
0x9693b006: ('unknown_0x9693b006', _decode_unknown_0x9693b006),
0x1e093b02: ('ghost_touched_sound_effect', _decode_ghost_touched_sound_effect),
0x2cf86398: ('unknown_0x2cf86398', _decode_unknown_0x2cf86398),
0x93d41865: ('unknown_0x93d41865', _decode_unknown_0x93d41865),
0x15406acb: ('unknown_0x15406acb', _decode_unknown_0x15406acb),
0xde1cb96e: ('unknown_0xde1cb96e', _decode_unknown_0xde1cb96e),
0x6b40acef: ('texture_set', _decode_texture_set),
0x961c0d17: ('auto_spin', _decode_auto_spin),
0xa755eb02: ('blink_out', _decode_blink_out),
0x69539dfc: ('unknown_0x69539dfc', _decode_unknown_0x69539dfc),
0x85cea266: ('can_render_sort', _decode_can_render_sort),
0x4ddc1327: ('unknown_0x4ddc1327', _decode_unknown_0x4ddc1327),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
0xbc96214f: ('pickup_delay', _decode_pickup_delay),
0xe722238d: ('unknown_0xe722238d', _decode_unknown_0xe722238d),
0xfc7cfe9b: ('unknown_0xfc7cfe9b', _decode_unknown_0xfc7cfe9b),
0xea3675c5: ('unknown_0xea3675c5', _decode_unknown_0xea3675c5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PickupData.py | 0.627381 | 0.179243 | PickupData.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 UnknownStruct280(BaseProperty):
unknown_0x968337ab: int = dataclasses.field(default=2)
unknown_0x8308e359: int = dataclasses.field(default=4)
unknown_0x5f86d272: float = dataclasses.field(default=2.0)
unknown_0xbd50eb30: float = dataclasses.field(default=1.0)
unknown_0x72d0dc87: float = dataclasses.field(default=30.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'\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'_\x86\xd2r') # 0x5f86d272
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5f86d272))
data.write(b'\xbdP\xeb0') # 0xbd50eb30
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbd50eb30))
data.write(b'r\xd0\xdc\x87') # 0x72d0dc87
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72d0dc87))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x968337ab=data['unknown_0x968337ab'],
unknown_0x8308e359=data['unknown_0x8308e359'],
unknown_0x5f86d272=data['unknown_0x5f86d272'],
unknown_0xbd50eb30=data['unknown_0xbd50eb30'],
unknown_0x72d0dc87=data['unknown_0x72d0dc87'],
)
def to_json(self) -> dict:
return {
'unknown_0x968337ab': self.unknown_0x968337ab,
'unknown_0x8308e359': self.unknown_0x8308e359,
'unknown_0x5f86d272': self.unknown_0x5f86d272,
'unknown_0xbd50eb30': self.unknown_0xbd50eb30,
'unknown_0x72d0dc87': self.unknown_0x72d0dc87,
}
_FAST_FORMAT = None
_FAST_IDS = (0x968337ab, 0x8308e359, 0x5f86d272, 0xbd50eb30, 0x72d0dc87)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct280]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct280(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
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_0x5f86d272(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbd50eb30(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x72d0dc87(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]]] = {
0x968337ab: ('unknown_0x968337ab', _decode_unknown_0x968337ab),
0x8308e359: ('unknown_0x8308e359', _decode_unknown_0x8308e359),
0x5f86d272: ('unknown_0x5f86d272', _decode_unknown_0x5f86d272),
0xbd50eb30: ('unknown_0xbd50eb30', _decode_unknown_0xbd50eb30),
0x72d0dc87: ('unknown_0x72d0dc87', _decode_unknown_0x72d0dc87),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct280.py | 0.580114 | 0.287085 | UnknownStruct280.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 DrivenIntoGroundBehaviorData(BaseProperty):
placeholder: 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'\xbb\x0e\x92L') # 0xbb0e924c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.placeholder))
@classmethod
def from_json(cls, data: dict):
return cls(
placeholder=data['placeholder'],
)
def to_json(self) -> dict:
return {
'placeholder': self.placeholder,
}
_FAST_FORMAT = None
_FAST_IDS = (0xbb0e924c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DrivenIntoGroundBehaviorData]:
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 DrivenIntoGroundBehaviorData(
dec[2],
)
def _decode_placeholder(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]]] = {
0xbb0e924c: ('placeholder', _decode_placeholder),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DrivenIntoGroundBehaviorData.py | 0.617282 | 0.308301 | DrivenIntoGroundBehaviorData.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 UnknownStruct196(BaseProperty):
launch_direction: enums.LaunchDirection = dataclasses.field(default=enums.LaunchDirection.Unknown1)
unknown: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=0.0, z=0.0))
initial_velocity: float = dataclasses.field(default=10.0)
gravity: 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\x04') # 4 properties
data.write(b'\x1f~\xf4I') # 0x1f7ef449
data.write(b'\x00\x04') # size
self.launch_direction.to_stream(data)
data.write(b'\xc0\x02R\x00') # 0xc0025200
data.write(b'\x00\x0c') # size
self.unknown.to_stream(data)
data.write(b'\x81G0\x93') # 0x81473093
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_velocity))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
@classmethod
def from_json(cls, data: dict):
return cls(
launch_direction=enums.LaunchDirection.from_json(data['launch_direction']),
unknown=Vector.from_json(data['unknown']),
initial_velocity=data['initial_velocity'],
gravity=data['gravity'],
)
def to_json(self) -> dict:
return {
'launch_direction': self.launch_direction.to_json(),
'unknown': self.unknown.to_json(),
'initial_velocity': self.initial_velocity,
'gravity': self.gravity,
}
def _decode_launch_direction(data: typing.BinaryIO, property_size: int):
return enums.LaunchDirection.from_stream(data)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_initial_velocity(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1f7ef449: ('launch_direction', _decode_launch_direction),
0xc0025200: ('unknown', _decode_unknown),
0x81473093: ('initial_velocity', _decode_initial_velocity),
0x2f2ae3e5: ('gravity', _decode_gravity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct196.py | 0.701917 | 0.328408 | UnknownStruct196.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.CameraShakerEnvelope import CameraShakerEnvelope
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class CameraShakerData(BaseProperty):
flags_camera_shaker: int = dataclasses.field(default=528)
attenuation_distance: float = dataclasses.field(default=5.0)
duration: float = dataclasses.field(default=1.0)
audio_effect: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
horizontal_motion: CameraShakerEnvelope = dataclasses.field(default_factory=CameraShakerEnvelope)
vertical_motion: CameraShakerEnvelope = dataclasses.field(default_factory=CameraShakerEnvelope)
forward_motion: CameraShakerEnvelope = dataclasses.field(default_factory=CameraShakerEnvelope)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\xc3\xe7\\_') # 0xc3e75c5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_camera_shaker))
data.write(b'M(:\xc5') # 0x4d283ac5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attenuation_distance))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\xc2\xac\xb7\x9e') # 0xc2acb79e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.audio_effect))
data.write(b'\xd9\xebq\xe0') # 0xd9eb71e0
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'\xc5\xb0\x962') # 0xc5b09632
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'!\xb7\x04\xe3') # 0x21b704e3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forward_motion.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_camera_shaker=data['flags_camera_shaker'],
attenuation_distance=data['attenuation_distance'],
duration=data['duration'],
audio_effect=data['audio_effect'],
horizontal_motion=CameraShakerEnvelope.from_json(data['horizontal_motion']),
vertical_motion=CameraShakerEnvelope.from_json(data['vertical_motion']),
forward_motion=CameraShakerEnvelope.from_json(data['forward_motion']),
)
def to_json(self) -> dict:
return {
'flags_camera_shaker': self.flags_camera_shaker,
'attenuation_distance': self.attenuation_distance,
'duration': self.duration,
'audio_effect': self.audio_effect,
'horizontal_motion': self.horizontal_motion.to_json(),
'vertical_motion': self.vertical_motion.to_json(),
'forward_motion': self.forward_motion.to_json(),
}
def _decode_flags_camera_shaker(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_attenuation_distance(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_audio_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_horizontal_motion(data: typing.BinaryIO, property_size: int):
return CameraShakerEnvelope.from_stream(data, property_size)
def _decode_vertical_motion(data: typing.BinaryIO, property_size: int):
return CameraShakerEnvelope.from_stream(data, property_size)
def _decode_forward_motion(data: typing.BinaryIO, property_size: int):
return CameraShakerEnvelope.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc3e75c5f: ('flags_camera_shaker', _decode_flags_camera_shaker),
0x4d283ac5: ('attenuation_distance', _decode_attenuation_distance),
0x8b51e23f: ('duration', _decode_duration),
0xc2acb79e: ('audio_effect', _decode_audio_effect),
0xd9eb71e0: ('horizontal_motion', _decode_horizontal_motion),
0xc5b09632: ('vertical_motion', _decode_vertical_motion),
0x21b704e3: ('forward_motion', _decode_forward_motion),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraShakerData.py | 0.685107 | 0.261649 | CameraShakerData.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.UnknownStruct192 import UnknownStruct192
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct56 import UnknownStruct56
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class JungleBossStructA(BaseProperty):
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
health: float = dataclasses.field(default=15.0)
unknown_struct56_0x02eb59dc: UnknownStruct56 = dataclasses.field(default_factory=UnknownStruct56)
unknown_struct56_0xf0bcb424: UnknownStruct56 = dataclasses.field(default_factory=UnknownStruct56)
unknown_struct56_0x17a112b3: UnknownStruct56 = dataclasses.field(default_factory=UnknownStruct56)
unknown_struct56_0xcf626995: UnknownStruct56 = dataclasses.field(default_factory=UnknownStruct56)
unknown_struct56_0x287fcf02: UnknownStruct56 = dataclasses.field(default_factory=UnknownStruct56)
unknown_struct192: UnknownStruct192 = dataclasses.field(default_factory=UnknownStruct192)
@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'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture))
data.write(b'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
data.write(b'\x02\xebY\xdc') # 0x2eb59dc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct56_0x02eb59dc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf0\xbc\xb4$') # 0xf0bcb424
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct56_0xf0bcb424.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xa1\x12\xb3') # 0x17a112b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct56_0x17a112b3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcfbi\x95') # 0xcf626995
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct56_0xcf626995.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x7f\xcf\x02') # 0x287fcf02
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct56_0x287fcf02.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'rTJ\xfd') # 0x72544afd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct192.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(
texture=data['texture'],
health=data['health'],
unknown_struct56_0x02eb59dc=UnknownStruct56.from_json(data['unknown_struct56_0x02eb59dc']),
unknown_struct56_0xf0bcb424=UnknownStruct56.from_json(data['unknown_struct56_0xf0bcb424']),
unknown_struct56_0x17a112b3=UnknownStruct56.from_json(data['unknown_struct56_0x17a112b3']),
unknown_struct56_0xcf626995=UnknownStruct56.from_json(data['unknown_struct56_0xcf626995']),
unknown_struct56_0x287fcf02=UnknownStruct56.from_json(data['unknown_struct56_0x287fcf02']),
unknown_struct192=UnknownStruct192.from_json(data['unknown_struct192']),
)
def to_json(self) -> dict:
return {
'texture': self.texture,
'health': self.health,
'unknown_struct56_0x02eb59dc': self.unknown_struct56_0x02eb59dc.to_json(),
'unknown_struct56_0xf0bcb424': self.unknown_struct56_0xf0bcb424.to_json(),
'unknown_struct56_0x17a112b3': self.unknown_struct56_0x17a112b3.to_json(),
'unknown_struct56_0xcf626995': self.unknown_struct56_0xcf626995.to_json(),
'unknown_struct56_0x287fcf02': self.unknown_struct56_0x287fcf02.to_json(),
'unknown_struct192': self.unknown_struct192.to_json(),
}
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct56_0x02eb59dc(data: typing.BinaryIO, property_size: int):
return UnknownStruct56.from_stream(data, property_size)
def _decode_unknown_struct56_0xf0bcb424(data: typing.BinaryIO, property_size: int):
return UnknownStruct56.from_stream(data, property_size)
def _decode_unknown_struct56_0x17a112b3(data: typing.BinaryIO, property_size: int):
return UnknownStruct56.from_stream(data, property_size)
def _decode_unknown_struct56_0xcf626995(data: typing.BinaryIO, property_size: int):
return UnknownStruct56.from_stream(data, property_size)
def _decode_unknown_struct56_0x287fcf02(data: typing.BinaryIO, property_size: int):
return UnknownStruct56.from_stream(data, property_size)
def _decode_unknown_struct192(data: typing.BinaryIO, property_size: int):
return UnknownStruct192.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd1f65872: ('texture', _decode_texture),
0xf0668919: ('health', _decode_health),
0x2eb59dc: ('unknown_struct56_0x02eb59dc', _decode_unknown_struct56_0x02eb59dc),
0xf0bcb424: ('unknown_struct56_0xf0bcb424', _decode_unknown_struct56_0xf0bcb424),
0x17a112b3: ('unknown_struct56_0x17a112b3', _decode_unknown_struct56_0x17a112b3),
0xcf626995: ('unknown_struct56_0xcf626995', _decode_unknown_struct56_0xcf626995),
0x287fcf02: ('unknown_struct56_0x287fcf02', _decode_unknown_struct56_0x287fcf02),
0x72544afd: ('unknown_struct192', _decode_unknown_struct192),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/JungleBossStructA.py | 0.580709 | 0.256739 | JungleBossStructA.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.FOVInterpolationMethod import FOVInterpolationMethod
from retro_data_structures.properties.dkc_returns.archetypes.MotionInterpolationMethod import MotionInterpolationMethod
from retro_data_structures.properties.dkc_returns.archetypes.OrientationInterpolationMethod import OrientationInterpolationMethod
@dataclasses.dataclass()
class CameraInterpolation(BaseProperty):
on_flags: int = dataclasses.field(default=3)
on_distance: float = dataclasses.field(default=100.0)
on_angle: float = dataclasses.field(default=135.0)
motion_interpolation_on: MotionInterpolationMethod = dataclasses.field(default_factory=MotionInterpolationMethod)
orientation_interpolation_on: OrientationInterpolationMethod = dataclasses.field(default_factory=OrientationInterpolationMethod)
fov_interpolation_on: FOVInterpolationMethod = dataclasses.field(default_factory=FOVInterpolationMethod)
off_flags: int = dataclasses.field(default=3)
off_distance: float = dataclasses.field(default=100.0)
off_angle: float = dataclasses.field(default=135.0)
motion_interpolation_off: MotionInterpolationMethod = dataclasses.field(default_factory=MotionInterpolationMethod)
orientation_interpolation_off: OrientationInterpolationMethod = dataclasses.field(default_factory=OrientationInterpolationMethod)
fov_interpolation_off: FOVInterpolationMethod = dataclasses.field(default_factory=FOVInterpolationMethod)
custom_flags: int = dataclasses.field(default=3)
custom_distance: float = dataclasses.field(default=100.0)
custom_angle: float = dataclasses.field(default=135.0)
motion_interpolation_custom: MotionInterpolationMethod = dataclasses.field(default_factory=MotionInterpolationMethod)
orientation_interpolation_custom: OrientationInterpolationMethod = dataclasses.field(default_factory=OrientationInterpolationMethod)
fov_interpolation_method: FOVInterpolationMethod = dataclasses.field(default_factory=FOVInterpolationMethod)
@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'\x1dI\xd3\\') # 0x1d49d35c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.on_flags))
data.write(b'\xc2-d\x92') # 0xc22d6492
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.on_distance))
data.write(b'\xe0 "\xd5') # 0xe02022d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.on_angle))
data.write(b'\xa78y\n') # 0xa738790a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_interpolation_on.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7h\xa1\x8e') # 0xa768a18e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_interpolation_on.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\x8c|\xb4') # 0x3b8c7cb4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_interpolation_on.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05\x8c\x1b\x1d') # 0x58c1b1d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.off_flags))
data.write(b"\x94?\x8a'") # 0x943f8a27
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.off_distance))
data.write(b"1'\xe6\x8a") # 0x3127e68a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.off_angle))
data.write(b'\x7f\xacs*') # 0x7fac732a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_interpolation_off.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\xabs\xb6') # 0xdfab73b6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_interpolation_off.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3\x91\xed\xbc') # 0xf391edbc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_interpolation_off.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x07\xa6\xc2,') # 0x7a6c22c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.custom_flags))
data.write(b'\xc4\xe7@\x18') # 0xc4e74018
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.custom_distance))
data.write(b'(\xb3\xb4\xb5') # 0x28b3b4b5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.custom_angle))
data.write(b'\xbcr<\xac') # 0xbc723cac
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_interpolation_custom.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbe\t6v') # 0xbe093676
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_interpolation_custom.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'puN\x15') # 0x70754e15
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_interpolation_method.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(
on_flags=data['on_flags'],
on_distance=data['on_distance'],
on_angle=data['on_angle'],
motion_interpolation_on=MotionInterpolationMethod.from_json(data['motion_interpolation_on']),
orientation_interpolation_on=OrientationInterpolationMethod.from_json(data['orientation_interpolation_on']),
fov_interpolation_on=FOVInterpolationMethod.from_json(data['fov_interpolation_on']),
off_flags=data['off_flags'],
off_distance=data['off_distance'],
off_angle=data['off_angle'],
motion_interpolation_off=MotionInterpolationMethod.from_json(data['motion_interpolation_off']),
orientation_interpolation_off=OrientationInterpolationMethod.from_json(data['orientation_interpolation_off']),
fov_interpolation_off=FOVInterpolationMethod.from_json(data['fov_interpolation_off']),
custom_flags=data['custom_flags'],
custom_distance=data['custom_distance'],
custom_angle=data['custom_angle'],
motion_interpolation_custom=MotionInterpolationMethod.from_json(data['motion_interpolation_custom']),
orientation_interpolation_custom=OrientationInterpolationMethod.from_json(data['orientation_interpolation_custom']),
fov_interpolation_method=FOVInterpolationMethod.from_json(data['fov_interpolation_method']),
)
def to_json(self) -> dict:
return {
'on_flags': self.on_flags,
'on_distance': self.on_distance,
'on_angle': self.on_angle,
'motion_interpolation_on': self.motion_interpolation_on.to_json(),
'orientation_interpolation_on': self.orientation_interpolation_on.to_json(),
'fov_interpolation_on': self.fov_interpolation_on.to_json(),
'off_flags': self.off_flags,
'off_distance': self.off_distance,
'off_angle': self.off_angle,
'motion_interpolation_off': self.motion_interpolation_off.to_json(),
'orientation_interpolation_off': self.orientation_interpolation_off.to_json(),
'fov_interpolation_off': self.fov_interpolation_off.to_json(),
'custom_flags': self.custom_flags,
'custom_distance': self.custom_distance,
'custom_angle': self.custom_angle,
'motion_interpolation_custom': self.motion_interpolation_custom.to_json(),
'orientation_interpolation_custom': self.orientation_interpolation_custom.to_json(),
'fov_interpolation_method': self.fov_interpolation_method.to_json(),
}
def _decode_on_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_on_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_on_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_motion_interpolation_on(data: typing.BinaryIO, property_size: int):
return MotionInterpolationMethod.from_stream(data, property_size)
def _decode_orientation_interpolation_on(data: typing.BinaryIO, property_size: int):
return OrientationInterpolationMethod.from_stream(data, property_size)
def _decode_fov_interpolation_on(data: typing.BinaryIO, property_size: int):
return FOVInterpolationMethod.from_stream(data, property_size)
def _decode_off_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_off_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_off_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_motion_interpolation_off(data: typing.BinaryIO, property_size: int):
return MotionInterpolationMethod.from_stream(data, property_size)
def _decode_orientation_interpolation_off(data: typing.BinaryIO, property_size: int):
return OrientationInterpolationMethod.from_stream(data, property_size)
def _decode_fov_interpolation_off(data: typing.BinaryIO, property_size: int):
return FOVInterpolationMethod.from_stream(data, property_size)
def _decode_custom_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_custom_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_custom_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_motion_interpolation_custom(data: typing.BinaryIO, property_size: int):
return MotionInterpolationMethod.from_stream(data, property_size)
def _decode_orientation_interpolation_custom(data: typing.BinaryIO, property_size: int):
return OrientationInterpolationMethod.from_stream(data, property_size)
def _decode_fov_interpolation_method(data: typing.BinaryIO, property_size: int):
return FOVInterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1d49d35c: ('on_flags', _decode_on_flags),
0xc22d6492: ('on_distance', _decode_on_distance),
0xe02022d5: ('on_angle', _decode_on_angle),
0xa738790a: ('motion_interpolation_on', _decode_motion_interpolation_on),
0xa768a18e: ('orientation_interpolation_on', _decode_orientation_interpolation_on),
0x3b8c7cb4: ('fov_interpolation_on', _decode_fov_interpolation_on),
0x58c1b1d: ('off_flags', _decode_off_flags),
0x943f8a27: ('off_distance', _decode_off_distance),
0x3127e68a: ('off_angle', _decode_off_angle),
0x7fac732a: ('motion_interpolation_off', _decode_motion_interpolation_off),
0xdfab73b6: ('orientation_interpolation_off', _decode_orientation_interpolation_off),
0xf391edbc: ('fov_interpolation_off', _decode_fov_interpolation_off),
0x7a6c22c: ('custom_flags', _decode_custom_flags),
0xc4e74018: ('custom_distance', _decode_custom_distance),
0x28b3b4b5: ('custom_angle', _decode_custom_angle),
0xbc723cac: ('motion_interpolation_custom', _decode_motion_interpolation_custom),
0xbe093676: ('orientation_interpolation_custom', _decode_orientation_interpolation_custom),
0x70754e15: ('fov_interpolation_method', _decode_fov_interpolation_method),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraInterpolation.py | 0.578448 | 0.292305 | CameraInterpolation.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.VolcanoBossBodyPartStructD import VolcanoBossBodyPartStructD
@dataclasses.dataclass()
class UnknownStruct293(BaseProperty):
unknown: int = dataclasses.field(default=0)
volcano_boss_body_part_struct_d_0x4266606e: VolcanoBossBodyPartStructD = dataclasses.field(default_factory=VolcanoBossBodyPartStructD)
volcano_boss_body_part_struct_d_0x06c74576: VolcanoBossBodyPartStructD = dataclasses.field(default_factory=VolcanoBossBodyPartStructD)
volcano_boss_body_part_struct_d_0x3aa7a67e: VolcanoBossBodyPartStructD = dataclasses.field(default_factory=VolcanoBossBodyPartStructD)
volcano_boss_body_part_struct_d_0x8f850f46: VolcanoBossBodyPartStructD = dataclasses.field(default_factory=VolcanoBossBodyPartStructD)
volcano_boss_body_part_struct_d_0xb3e5ec4e: VolcanoBossBodyPartStructD = dataclasses.field(default_factory=VolcanoBossBodyPartStructD)
volcano_boss_body_part_struct_d_0xf744c956: VolcanoBossBodyPartStructD = dataclasses.field(default_factory=VolcanoBossBodyPartStructD)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x06\xef\xda\xb2') # 0x6efdab2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'Bf`n') # 0x4266606e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_d_0x4266606e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x06\xc7Ev') # 0x6c74576
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_d_0x06c74576.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b':\xa7\xa6~') # 0x3aa7a67e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_d_0x3aa7a67e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8f\x85\x0fF') # 0x8f850f46
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_d_0x8f850f46.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\xe5\xecN') # 0xb3e5ec4e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_d_0xb3e5ec4e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7D\xc9V') # 0xf744c956
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_d_0xf744c956.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'],
volcano_boss_body_part_struct_d_0x4266606e=VolcanoBossBodyPartStructD.from_json(data['volcano_boss_body_part_struct_d_0x4266606e']),
volcano_boss_body_part_struct_d_0x06c74576=VolcanoBossBodyPartStructD.from_json(data['volcano_boss_body_part_struct_d_0x06c74576']),
volcano_boss_body_part_struct_d_0x3aa7a67e=VolcanoBossBodyPartStructD.from_json(data['volcano_boss_body_part_struct_d_0x3aa7a67e']),
volcano_boss_body_part_struct_d_0x8f850f46=VolcanoBossBodyPartStructD.from_json(data['volcano_boss_body_part_struct_d_0x8f850f46']),
volcano_boss_body_part_struct_d_0xb3e5ec4e=VolcanoBossBodyPartStructD.from_json(data['volcano_boss_body_part_struct_d_0xb3e5ec4e']),
volcano_boss_body_part_struct_d_0xf744c956=VolcanoBossBodyPartStructD.from_json(data['volcano_boss_body_part_struct_d_0xf744c956']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'volcano_boss_body_part_struct_d_0x4266606e': self.volcano_boss_body_part_struct_d_0x4266606e.to_json(),
'volcano_boss_body_part_struct_d_0x06c74576': self.volcano_boss_body_part_struct_d_0x06c74576.to_json(),
'volcano_boss_body_part_struct_d_0x3aa7a67e': self.volcano_boss_body_part_struct_d_0x3aa7a67e.to_json(),
'volcano_boss_body_part_struct_d_0x8f850f46': self.volcano_boss_body_part_struct_d_0x8f850f46.to_json(),
'volcano_boss_body_part_struct_d_0xb3e5ec4e': self.volcano_boss_body_part_struct_d_0xb3e5ec4e.to_json(),
'volcano_boss_body_part_struct_d_0xf744c956': self.volcano_boss_body_part_struct_d_0xf744c956.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volcano_boss_body_part_struct_d_0x4266606e(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructD.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_d_0x06c74576(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructD.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_d_0x3aa7a67e(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructD.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_d_0x8f850f46(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructD.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_d_0xb3e5ec4e(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructD.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_d_0xf744c956(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructD.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6efdab2: ('unknown', _decode_unknown),
0x4266606e: ('volcano_boss_body_part_struct_d_0x4266606e', _decode_volcano_boss_body_part_struct_d_0x4266606e),
0x6c74576: ('volcano_boss_body_part_struct_d_0x06c74576', _decode_volcano_boss_body_part_struct_d_0x06c74576),
0x3aa7a67e: ('volcano_boss_body_part_struct_d_0x3aa7a67e', _decode_volcano_boss_body_part_struct_d_0x3aa7a67e),
0x8f850f46: ('volcano_boss_body_part_struct_d_0x8f850f46', _decode_volcano_boss_body_part_struct_d_0x8f850f46),
0xb3e5ec4e: ('volcano_boss_body_part_struct_d_0xb3e5ec4e', _decode_volcano_boss_body_part_struct_d_0xb3e5ec4e),
0xf744c956: ('volcano_boss_body_part_struct_d_0xf744c956', _decode_volcano_boss_body_part_struct_d_0xf744c956),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct293.py | 0.527803 | 0.426202 | UnknownStruct293.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 UnknownStruct58(BaseProperty):
unknown_0x8a58a7f8: int = dataclasses.field(default=1)
unknown_0x72d0dc87: float = dataclasses.field(default=30.0)
unknown_0x8686fda9: int = dataclasses.field(default=1)
unknown_0xdd6a10b1: int = dataclasses.field(default=1)
wait_time0: float = dataclasses.field(default=1.0)
wait_time1: float = dataclasses.field(default=1.5)
wait_time2: float = dataclasses.field(default=2.0)
wait_time3: float = dataclasses.field(default=3.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\x08') # 8 properties
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'r\xd0\xdc\x87') # 0x72d0dc87
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72d0dc87))
data.write(b'\x86\x86\xfd\xa9') # 0x8686fda9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8686fda9))
data.write(b'\xddj\x10\xb1') # 0xdd6a10b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xdd6a10b1))
data.write(b'\x9dE\xfa\x96') # 0x9d45fa96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wait_time0))
data.write(b'V\x19)3') # 0x56192933
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wait_time1))
data.write(b'\xd0\x8d[\x9d') # 0xd08d5b9d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wait_time2))
data.write(b'\x1b\xd1\x888') # 0x1bd18838
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wait_time3))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
unknown_0x72d0dc87=data['unknown_0x72d0dc87'],
unknown_0x8686fda9=data['unknown_0x8686fda9'],
unknown_0xdd6a10b1=data['unknown_0xdd6a10b1'],
wait_time0=data['wait_time0'],
wait_time1=data['wait_time1'],
wait_time2=data['wait_time2'],
wait_time3=data['wait_time3'],
)
def to_json(self) -> dict:
return {
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'unknown_0x72d0dc87': self.unknown_0x72d0dc87,
'unknown_0x8686fda9': self.unknown_0x8686fda9,
'unknown_0xdd6a10b1': self.unknown_0xdd6a10b1,
'wait_time0': self.wait_time0,
'wait_time1': self.wait_time1,
'wait_time2': self.wait_time2,
'wait_time3': self.wait_time3,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8a58a7f8, 0x72d0dc87, 0x8686fda9, 0xdd6a10b1, 0x9d45fa96, 0x56192933, 0xd08d5b9d, 0x1bd18838)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct58]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHfLHlLHlLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(80))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct58(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x72d0dc87(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8686fda9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xdd6a10b1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_wait_time0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wait_time1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wait_time2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wait_time3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0x72d0dc87: ('unknown_0x72d0dc87', _decode_unknown_0x72d0dc87),
0x8686fda9: ('unknown_0x8686fda9', _decode_unknown_0x8686fda9),
0xdd6a10b1: ('unknown_0xdd6a10b1', _decode_unknown_0xdd6a10b1),
0x9d45fa96: ('wait_time0', _decode_wait_time0),
0x56192933: ('wait_time1', _decode_wait_time1),
0xd08d5b9d: ('wait_time2', _decode_wait_time2),
0x1bd18838: ('wait_time3', _decode_wait_time3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct58.py | 0.582729 | 0.289045 | UnknownStruct58.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 UnknownStruct228(BaseProperty):
death_time: float = dataclasses.field(default=2.0)
unknown: 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'\x07tc\xa3') # 0x77463a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.death_time))
data.write(b'\xf3\x87\xa1`') # 0xf387a160
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)
@classmethod
def from_json(cls, data: dict):
return cls(
death_time=data['death_time'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'death_time': self.death_time,
'unknown': self.unknown,
}
def _decode_death_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 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]]] = {
0x77463a3: ('death_time', _decode_death_time),
0xf387a160: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct228.py | 0.637257 | 0.306709 | UnknownStruct228.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.TriggerShape import TriggerShape
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class GroundPoundDetectorData(BaseProperty):
use_detection_shape_and_ignore_radius: bool = dataclasses.field(default=False)
trigger_shape: TriggerShape = dataclasses.field(default_factory=TriggerShape)
detection_vector: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
detection_angle_tolerance: float = dataclasses.field(default=5.0)
radius: float = dataclasses.field(default=5.0)
ignore_dk: bool = dataclasses.field(default=False)
ignore_diddy: bool = dataclasses.field(default=False)
ignore_rambi: bool = dataclasses.field(default=False)
use_originator_transform: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\xf2\x9d\xb9X') # 0xf29db958
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_detection_shape_and_ignore_radius))
data.write(b'\xbb,T\xe1') # 0xbb2c54e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger_shape.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\xa4m\x11') # 0x45a46d11
data.write(b'\x00\x0c') # size
self.detection_vector.to_stream(data)
data.write(b'\xbaH\xe8S') # 0xba48e853
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_angle_tolerance))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'%\xee_\xfb') # 0x25ee5ffb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_dk))
data.write(b'b\xa7\x13c') # 0x62a71363
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_diddy))
data.write(b'M\xb9\x02a') # 0x4db90261
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_rambi))
data.write(b'\x03Z^\x10') # 0x35a5e10
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_originator_transform))
@classmethod
def from_json(cls, data: dict):
return cls(
use_detection_shape_and_ignore_radius=data['use_detection_shape_and_ignore_radius'],
trigger_shape=TriggerShape.from_json(data['trigger_shape']),
detection_vector=Vector.from_json(data['detection_vector']),
detection_angle_tolerance=data['detection_angle_tolerance'],
radius=data['radius'],
ignore_dk=data['ignore_dk'],
ignore_diddy=data['ignore_diddy'],
ignore_rambi=data['ignore_rambi'],
use_originator_transform=data['use_originator_transform'],
)
def to_json(self) -> dict:
return {
'use_detection_shape_and_ignore_radius': self.use_detection_shape_and_ignore_radius,
'trigger_shape': self.trigger_shape.to_json(),
'detection_vector': self.detection_vector.to_json(),
'detection_angle_tolerance': self.detection_angle_tolerance,
'radius': self.radius,
'ignore_dk': self.ignore_dk,
'ignore_diddy': self.ignore_diddy,
'ignore_rambi': self.ignore_rambi,
'use_originator_transform': self.use_originator_transform,
}
def _decode_use_detection_shape_and_ignore_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_trigger_shape(data: typing.BinaryIO, property_size: int):
return TriggerShape.from_stream(data, property_size)
def _decode_detection_vector(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_detection_angle_tolerance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ignore_dk(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_diddy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_rambi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_originator_transform(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]]] = {
0xf29db958: ('use_detection_shape_and_ignore_radius', _decode_use_detection_shape_and_ignore_radius),
0xbb2c54e1: ('trigger_shape', _decode_trigger_shape),
0x45a46d11: ('detection_vector', _decode_detection_vector),
0xba48e853: ('detection_angle_tolerance', _decode_detection_angle_tolerance),
0x78c507eb: ('radius', _decode_radius),
0x25ee5ffb: ('ignore_dk', _decode_ignore_dk),
0x62a71363: ('ignore_diddy', _decode_ignore_diddy),
0x4db90261: ('ignore_rambi', _decode_ignore_rambi),
0x35a5e10: ('use_originator_transform', _decode_use_originator_transform),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GroundPoundDetectorData.py | 0.660282 | 0.399929 | GroundPoundDetectorData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
@dataclasses.dataclass()
class PlayerTeleportData(BaseProperty):
teleport_to_locator: str = dataclasses.field(default='')
teleport_render_push_amount: float = dataclasses.field(default=0.0)
teleport_method: Convergence = dataclasses.field(default_factory=Convergence)
@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'\xa6\xab\x86D') # 0xa6ab8644
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.teleport_to_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'J;\xce\xb4') # 0x4a3bceb4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.teleport_render_push_amount))
data.write(b'\xa0d}\xf6') # 0xa0647df6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.teleport_method.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(
teleport_to_locator=data['teleport_to_locator'],
teleport_render_push_amount=data['teleport_render_push_amount'],
teleport_method=Convergence.from_json(data['teleport_method']),
)
def to_json(self) -> dict:
return {
'teleport_to_locator': self.teleport_to_locator,
'teleport_render_push_amount': self.teleport_render_push_amount,
'teleport_method': self.teleport_method.to_json(),
}
def _decode_teleport_to_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_teleport_render_push_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_teleport_method(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa6ab8644: ('teleport_to_locator', _decode_teleport_to_locator),
0x4a3bceb4: ('teleport_render_push_amount', _decode_teleport_render_push_amount),
0xa0647df6: ('teleport_method', _decode_teleport_method),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerTeleportData.py | 0.589953 | 0.309924 | PlayerTeleportData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct30 import UnknownStruct30
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct31 import UnknownStruct31
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct148(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
audio: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
controllers: 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)
unknown_struct31: UnknownStruct31 = dataclasses.field(default_factory=UnknownStruct31)
unknown_struct30: UnknownStruct30 = dataclasses.field(default_factory=UnknownStruct30)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\xa0\x99\xca4') # 0xa099ca34
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.audio))
data.write(b'\xefY\xeaO') # 0xef59ea4f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.controllers))
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'\x07\xba\xa1\x1b') # 0x7baa11b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct31.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb/\xf7\x02') # 0xcb2ff702
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct30.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_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title=data['title'],
audio=data['audio'],
controllers=data['controllers'],
back=data['back'],
back_core=data['back_core'],
unknown_struct31=UnknownStruct31.from_json(data['unknown_struct31']),
unknown_struct30=UnknownStruct30.from_json(data['unknown_struct30']),
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title': self.title,
'audio': self.audio,
'controllers': self.controllers,
'back': self.back,
'back_core': self.back_core,
'unknown_struct31': self.unknown_struct31.to_json(),
'unknown_struct30': self.unknown_struct30.to_json(),
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_audio(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_controllers(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_unknown_struct31(data: typing.BinaryIO, property_size: int):
return UnknownStruct31.from_stream(data, property_size)
def _decode_unknown_struct30(data: typing.BinaryIO, property_size: int):
return UnknownStruct30.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0xa4f20c17: ('title', _decode_title),
0xa099ca34: ('audio', _decode_audio),
0xef59ea4f: ('controllers', _decode_controllers),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x7baa11b: ('unknown_struct31', _decode_unknown_struct31),
0xcb2ff702: ('unknown_struct30', _decode_unknown_struct30),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct148.py | 0.631367 | 0.218753 | UnknownStruct148.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct32(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)
motion_spline_loops: bool = dataclasses.field(default=False)
loop_forever: bool = dataclasses.field(default=False)
auto_start: 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\x08') # 8 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'\x7f\xc9`\x14') # 0x7fc96014
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.motion_spline_loops))
data.write(b'\x08\xbbs\xc5') # 0x8bb73c5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_forever))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
@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'],
motion_spline_loops=data['motion_spline_loops'],
loop_forever=data['loop_forever'],
auto_start=data['auto_start'],
)
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,
'motion_spline_loops': self.motion_spline_loops,
'loop_forever': self.loop_forever,
'auto_start': self.auto_start,
}
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_motion_spline_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_forever(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(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]]] = {
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),
0x7fc96014: ('motion_spline_loops', _decode_motion_spline_loops),
0x8bb73c5: ('loop_forever', _decode_loop_forever),
0x3217dff8: ('auto_start', _decode_auto_start),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct32.py | 0.680454 | 0.258367 | UnknownStruct32.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 CameraConstraints(BaseProperty):
unknown: int = dataclasses.field(default=1)
@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\xab\x96'") # 0x9ab9627
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', 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 = (0x9ab9627)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraConstraints]:
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 CameraConstraints(
dec[2],
)
def _decode_unknown(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]]] = {
0x9ab9627: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraConstraints.py | 0.64713 | 0.296196 | CameraConstraints.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 UnknownStruct253(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[UnknownStruct253]:
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 UnknownStruct253(
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/UnknownStruct253.py | 0.613352 | 0.313853 | UnknownStruct253.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 UnknownStruct47(BaseProperty):
crash_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
crash_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\x02') # 2 properties
data.write(b'\xa0n\xda\xf9') # 0xa06edaf9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crash_effect))
data.write(b'+%\x86)') # 0x2b258629
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.crash_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
crash_effect=data['crash_effect'],
crash_sound=data['crash_sound'],
)
def to_json(self) -> dict:
return {
'crash_effect': self.crash_effect,
'crash_sound': self.crash_sound,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa06edaf9, 0x2b258629)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct47]:
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 UnknownStruct47(
dec[2],
dec[5],
)
def _decode_crash_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_crash_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]]] = {
0xa06edaf9: ('crash_effect', _decode_crash_effect),
0x2b258629: ('crash_sound', _decode_crash_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct47.py | 0.616012 | 0.239827 | UnknownStruct47.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
@dataclasses.dataclass()
class CameraRotation(BaseProperty):
rotation_type: Convergence = dataclasses.field(default_factory=Convergence)
@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'\xfai\x88V') # 0xfa698856
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotation_type.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(
rotation_type=Convergence.from_json(data['rotation_type']),
)
def to_json(self) -> dict:
return {
'rotation_type': self.rotation_type.to_json(),
}
def _decode_rotation_type(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfa698856: ('rotation_type', _decode_rotation_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraRotation.py | 0.714927 | 0.300707 | CameraRotation.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 PlayerType(BaseProperty):
character_type: enums.CharacterType = dataclasses.field(default=enums.CharacterType.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't\x05\x9fY') # 0x74059f59
data.write(b'\x00\x04') # size
self.character_type.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
character_type=enums.CharacterType.from_json(data['character_type']),
)
def to_json(self) -> dict:
return {
'character_type': self.character_type.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x74059f59)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerType]:
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 PlayerType(
enums.CharacterType(dec[2]),
)
def _decode_character_type(data: typing.BinaryIO, property_size: int):
return enums.CharacterType.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x74059f59: ('character_type', _decode_character_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerType.py | 0.667148 | 0.299899 | PlayerType.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.UnknownStruct48 import UnknownStruct48
@dataclasses.dataclass()
class BirdBossStruct(BaseProperty):
attack_selector: enums.RobotChickenEnum = dataclasses.field(default=enums.RobotChickenEnum.Unknown1)
health: float = dataclasses.field(default=0.0)
acceleration: float = dataclasses.field(default=20.0)
deceleration: float = dataclasses.field(default=12.0)
maximum_speed: float = dataclasses.field(default=12.0)
unknown_0x40ec2d6f: int = dataclasses.field(default=2)
unknown_0x11acfd8e: int = dataclasses.field(default=2)
unknown_0xe2217298: int = dataclasses.field(default=4)
unknown_0xd87c0c65: float = dataclasses.field(default=0.5)
unknown_0x8f5ab554: float = dataclasses.field(default=0.699999988079071)
unknown_struct48_0x67490fee: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
unknown_struct48_0xc41f8947: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
unknown_struct48_0x13fd091f: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
unknown_struct48_0x59c38254: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
unknown_struct48_0x8e21020c: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
unknown_struct48_0x2d7784a5: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
unknown_struct48_0xfa9504fd: UnknownStruct48 = dataclasses.field(default_factory=UnknownStruct48)
@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'\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'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'@\xec-o') # 0x40ec2d6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x40ec2d6f))
data.write(b'\x11\xac\xfd\x8e') # 0x11acfd8e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x11acfd8e))
data.write(b'\xe2!r\x98') # 0xe2217298
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe2217298))
data.write(b'\xd8|\x0ce') # 0xd87c0c65
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd87c0c65))
data.write(b'\x8fZ\xb5T') # 0x8f5ab554
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8f5ab554))
data.write(b'gI\x0f\xee') # 0x67490fee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0x67490fee.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\x1f\x89G') # 0xc41f8947
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0xc41f8947.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x13\xfd\t\x1f') # 0x13fd091f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0x13fd091f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\xc3\x82T') # 0x59c38254
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0x59c38254.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8e!\x02\x0c') # 0x8e21020c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0x8e21020c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-w\x84\xa5') # 0x2d7784a5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0x2d7784a5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa\x95\x04\xfd') # 0xfa9504fd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct48_0xfa9504fd.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'],
acceleration=data['acceleration'],
deceleration=data['deceleration'],
maximum_speed=data['maximum_speed'],
unknown_0x40ec2d6f=data['unknown_0x40ec2d6f'],
unknown_0x11acfd8e=data['unknown_0x11acfd8e'],
unknown_0xe2217298=data['unknown_0xe2217298'],
unknown_0xd87c0c65=data['unknown_0xd87c0c65'],
unknown_0x8f5ab554=data['unknown_0x8f5ab554'],
unknown_struct48_0x67490fee=UnknownStruct48.from_json(data['unknown_struct48_0x67490fee']),
unknown_struct48_0xc41f8947=UnknownStruct48.from_json(data['unknown_struct48_0xc41f8947']),
unknown_struct48_0x13fd091f=UnknownStruct48.from_json(data['unknown_struct48_0x13fd091f']),
unknown_struct48_0x59c38254=UnknownStruct48.from_json(data['unknown_struct48_0x59c38254']),
unknown_struct48_0x8e21020c=UnknownStruct48.from_json(data['unknown_struct48_0x8e21020c']),
unknown_struct48_0x2d7784a5=UnknownStruct48.from_json(data['unknown_struct48_0x2d7784a5']),
unknown_struct48_0xfa9504fd=UnknownStruct48.from_json(data['unknown_struct48_0xfa9504fd']),
)
def to_json(self) -> dict:
return {
'attack_selector': self.attack_selector.to_json(),
'health': self.health,
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'maximum_speed': self.maximum_speed,
'unknown_0x40ec2d6f': self.unknown_0x40ec2d6f,
'unknown_0x11acfd8e': self.unknown_0x11acfd8e,
'unknown_0xe2217298': self.unknown_0xe2217298,
'unknown_0xd87c0c65': self.unknown_0xd87c0c65,
'unknown_0x8f5ab554': self.unknown_0x8f5ab554,
'unknown_struct48_0x67490fee': self.unknown_struct48_0x67490fee.to_json(),
'unknown_struct48_0xc41f8947': self.unknown_struct48_0xc41f8947.to_json(),
'unknown_struct48_0x13fd091f': self.unknown_struct48_0x13fd091f.to_json(),
'unknown_struct48_0x59c38254': self.unknown_struct48_0x59c38254.to_json(),
'unknown_struct48_0x8e21020c': self.unknown_struct48_0x8e21020c.to_json(),
'unknown_struct48_0x2d7784a5': self.unknown_struct48_0x2d7784a5.to_json(),
'unknown_struct48_0xfa9504fd': self.unknown_struct48_0xfa9504fd.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_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_0x40ec2d6f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x11acfd8e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xe2217298(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd87c0c65(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8f5ab554(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct48_0x67490fee(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.from_stream(data, property_size)
def _decode_unknown_struct48_0xc41f8947(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.from_stream(data, property_size)
def _decode_unknown_struct48_0x13fd091f(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.from_stream(data, property_size)
def _decode_unknown_struct48_0x59c38254(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.from_stream(data, property_size)
def _decode_unknown_struct48_0x8e21020c(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.from_stream(data, property_size)
def _decode_unknown_struct48_0x2d7784a5(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.from_stream(data, property_size)
def _decode_unknown_struct48_0xfa9504fd(data: typing.BinaryIO, property_size: int):
return UnknownStruct48.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),
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
0x40ec2d6f: ('unknown_0x40ec2d6f', _decode_unknown_0x40ec2d6f),
0x11acfd8e: ('unknown_0x11acfd8e', _decode_unknown_0x11acfd8e),
0xe2217298: ('unknown_0xe2217298', _decode_unknown_0xe2217298),
0xd87c0c65: ('unknown_0xd87c0c65', _decode_unknown_0xd87c0c65),
0x8f5ab554: ('unknown_0x8f5ab554', _decode_unknown_0x8f5ab554),
0x67490fee: ('unknown_struct48_0x67490fee', _decode_unknown_struct48_0x67490fee),
0xc41f8947: ('unknown_struct48_0xc41f8947', _decode_unknown_struct48_0xc41f8947),
0x13fd091f: ('unknown_struct48_0x13fd091f', _decode_unknown_struct48_0x13fd091f),
0x59c38254: ('unknown_struct48_0x59c38254', _decode_unknown_struct48_0x59c38254),
0x8e21020c: ('unknown_struct48_0x8e21020c', _decode_unknown_struct48_0x8e21020c),
0x2d7784a5: ('unknown_struct48_0x2d7784a5', _decode_unknown_struct48_0x2d7784a5),
0xfa9504fd: ('unknown_struct48_0xfa9504fd', _decode_unknown_struct48_0xfa9504fd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BirdBossStruct.py | 0.588061 | 0.255001 | BirdBossStruct.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.UnknownStruct54 import UnknownStruct54
@dataclasses.dataclass()
class UnknownStruct53(BaseProperty):
unknown_struct54: UnknownStruct54 = dataclasses.field(default_factory=UnknownStruct54)
insert_chance: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'E\xd3\x90\x80') # 0x45d39080
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct54.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1f\x9b\xcb\x8f') # 0x1f9bcb8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.insert_chance))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct54=UnknownStruct54.from_json(data['unknown_struct54']),
insert_chance=data['insert_chance'],
)
def to_json(self) -> dict:
return {
'unknown_struct54': self.unknown_struct54.to_json(),
'insert_chance': self.insert_chance,
}
def _decode_unknown_struct54(data: typing.BinaryIO, property_size: int):
return UnknownStruct54.from_stream(data, property_size)
def _decode_insert_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x45d39080: ('unknown_struct54', _decode_unknown_struct54),
0x1f9bcb8f: ('insert_chance', _decode_insert_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct53.py | 0.614625 | 0.293471 | UnknownStruct53.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.UnknownStruct256 import UnknownStruct256
@dataclasses.dataclass()
class UnknownStruct257(BaseProperty):
unknown_0x1b5993a1: bool = dataclasses.field(default=False)
unknown_0xf57d16e4: bool = dataclasses.field(default=False)
unknown_0xb646a87e: bool = dataclasses.field(default=True)
unknown_0x3818a74b: bool = dataclasses.field(default=True)
unknown_0xb95d2954: bool = dataclasses.field(default=False)
unknown_0x6551fc4a: bool = dataclasses.field(default=False)
use_player_knockback: bool = dataclasses.field(default=True)
use_player_push: bool = dataclasses.field(default=False)
use_player_hurl: bool = dataclasses.field(default=False)
anim_scale: float = dataclasses.field(default=1.0)
unknown_0x626fa43d: float = dataclasses.field(default=1.0)
unknown_struct256: UnknownStruct256 = dataclasses.field(default_factory=UnknownStruct256)
@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'\x1bY\x93\xa1') # 0x1b5993a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x1b5993a1))
data.write(b'\xf5}\x16\xe4') # 0xf57d16e4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf57d16e4))
data.write(b'\xb6F\xa8~') # 0xb646a87e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb646a87e))
data.write(b'8\x18\xa7K') # 0x3818a74b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3818a74b))
data.write(b'\xb9])T') # 0xb95d2954
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb95d2954))
data.write(b'eQ\xfcJ') # 0x6551fc4a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x6551fc4a))
data.write(b'\x16\x80\xa2T') # 0x1680a254
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_player_knockback))
data.write(b'\xd8\xb8\x84\xad') # 0xd8b884ad
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_player_push))
data.write(b'I:\xdbV') # 0x493adb56
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_player_hurl))
data.write(b'\x18x\xfa\x08') # 0x1878fa08
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.anim_scale))
data.write(b'bo\xa4=') # 0x626fa43d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x626fa43d))
data.write(b'\xbc\x98t\x8c') # 0xbc98748c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct256.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_0x1b5993a1=data['unknown_0x1b5993a1'],
unknown_0xf57d16e4=data['unknown_0xf57d16e4'],
unknown_0xb646a87e=data['unknown_0xb646a87e'],
unknown_0x3818a74b=data['unknown_0x3818a74b'],
unknown_0xb95d2954=data['unknown_0xb95d2954'],
unknown_0x6551fc4a=data['unknown_0x6551fc4a'],
use_player_knockback=data['use_player_knockback'],
use_player_push=data['use_player_push'],
use_player_hurl=data['use_player_hurl'],
anim_scale=data['anim_scale'],
unknown_0x626fa43d=data['unknown_0x626fa43d'],
unknown_struct256=UnknownStruct256.from_json(data['unknown_struct256']),
)
def to_json(self) -> dict:
return {
'unknown_0x1b5993a1': self.unknown_0x1b5993a1,
'unknown_0xf57d16e4': self.unknown_0xf57d16e4,
'unknown_0xb646a87e': self.unknown_0xb646a87e,
'unknown_0x3818a74b': self.unknown_0x3818a74b,
'unknown_0xb95d2954': self.unknown_0xb95d2954,
'unknown_0x6551fc4a': self.unknown_0x6551fc4a,
'use_player_knockback': self.use_player_knockback,
'use_player_push': self.use_player_push,
'use_player_hurl': self.use_player_hurl,
'anim_scale': self.anim_scale,
'unknown_0x626fa43d': self.unknown_0x626fa43d,
'unknown_struct256': self.unknown_struct256.to_json(),
}
def _decode_unknown_0x1b5993a1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf57d16e4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb646a87e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x3818a74b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb95d2954(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x6551fc4a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_player_knockback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_player_push(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_player_hurl(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_anim_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x626fa43d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct256(data: typing.BinaryIO, property_size: int):
return UnknownStruct256.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1b5993a1: ('unknown_0x1b5993a1', _decode_unknown_0x1b5993a1),
0xf57d16e4: ('unknown_0xf57d16e4', _decode_unknown_0xf57d16e4),
0xb646a87e: ('unknown_0xb646a87e', _decode_unknown_0xb646a87e),
0x3818a74b: ('unknown_0x3818a74b', _decode_unknown_0x3818a74b),
0xb95d2954: ('unknown_0xb95d2954', _decode_unknown_0xb95d2954),
0x6551fc4a: ('unknown_0x6551fc4a', _decode_unknown_0x6551fc4a),
0x1680a254: ('use_player_knockback', _decode_use_player_knockback),
0xd8b884ad: ('use_player_push', _decode_use_player_push),
0x493adb56: ('use_player_hurl', _decode_use_player_hurl),
0x1878fa08: ('anim_scale', _decode_anim_scale),
0x626fa43d: ('unknown_0x626fa43d', _decode_unknown_0x626fa43d),
0xbc98748c: ('unknown_struct256', _decode_unknown_struct256),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct257.py | 0.557364 | 0.283561 | UnknownStruct257.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 UnknownStruct239(BaseProperty):
spawn_delay: float = dataclasses.field(default=1.0)
unknown_0xb1351a96: float = dataclasses.field(default=0.6600000262260437)
spawn_hazard_time: float = dataclasses.field(default=0.25)
flip_time: float = dataclasses.field(default=2.0)
medium_idle_time: float = dataclasses.field(default=1.25)
long_idle_time: float = dataclasses.field(default=2.0)
unknown_0x7850d13c: float = dataclasses.field(default=0.5)
unknown_0xde1a7739: float = dataclasses.field(default=0.25)
unknown_0xeddfb002: float = dataclasses.field(default=0.0)
unknown_0x62ca4939: float = dataclasses.field(default=0.0)
fake_spawn_delay: float = dataclasses.field(default=0.0)
unknown_0x086e29df: 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\x0c') # 12 properties
data.write(b'\xd48s\x9d') # 0xd438739d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spawn_delay))
data.write(b'\xb15\x1a\x96') # 0xb1351a96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb1351a96))
data.write(b'\xa3t)\xee') # 0xa37429ee
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spawn_hazard_time))
data.write(b'@\xaeJ\t') # 0x40ae4a09
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flip_time))
data.write(b'\x97G=\xac') # 0x97473dac
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.medium_idle_time))
data.write(b".1't") # 0x2e312774
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.long_idle_time))
data.write(b'xP\xd1<') # 0x7850d13c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7850d13c))
data.write(b'\xde\x1aw9') # 0xde1a7739
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xde1a7739))
data.write(b'\xed\xdf\xb0\x02') # 0xeddfb002
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xeddfb002))
data.write(b'b\xcaI9') # 0x62ca4939
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x62ca4939))
data.write(b'\x84\xd93\x1a') # 0x84d9331a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fake_spawn_delay))
data.write(b'\x08n)\xdf') # 0x86e29df
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x086e29df))
@classmethod
def from_json(cls, data: dict):
return cls(
spawn_delay=data['spawn_delay'],
unknown_0xb1351a96=data['unknown_0xb1351a96'],
spawn_hazard_time=data['spawn_hazard_time'],
flip_time=data['flip_time'],
medium_idle_time=data['medium_idle_time'],
long_idle_time=data['long_idle_time'],
unknown_0x7850d13c=data['unknown_0x7850d13c'],
unknown_0xde1a7739=data['unknown_0xde1a7739'],
unknown_0xeddfb002=data['unknown_0xeddfb002'],
unknown_0x62ca4939=data['unknown_0x62ca4939'],
fake_spawn_delay=data['fake_spawn_delay'],
unknown_0x086e29df=data['unknown_0x086e29df'],
)
def to_json(self) -> dict:
return {
'spawn_delay': self.spawn_delay,
'unknown_0xb1351a96': self.unknown_0xb1351a96,
'spawn_hazard_time': self.spawn_hazard_time,
'flip_time': self.flip_time,
'medium_idle_time': self.medium_idle_time,
'long_idle_time': self.long_idle_time,
'unknown_0x7850d13c': self.unknown_0x7850d13c,
'unknown_0xde1a7739': self.unknown_0xde1a7739,
'unknown_0xeddfb002': self.unknown_0xeddfb002,
'unknown_0x62ca4939': self.unknown_0x62ca4939,
'fake_spawn_delay': self.fake_spawn_delay,
'unknown_0x086e29df': self.unknown_0x086e29df,
}
_FAST_FORMAT = None
_FAST_IDS = (0xd438739d, 0xb1351a96, 0xa37429ee, 0x40ae4a09, 0x97473dac, 0x2e312774, 0x7850d13c, 0xde1a7739, 0xeddfb002, 0x62ca4939, 0x84d9331a, 0x86e29df)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct239]:
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 UnknownStruct239(
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_spawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb1351a96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spawn_hazard_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flip_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_medium_idle_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_long_idle_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7850d13c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xde1a7739(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xeddfb002(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x62ca4939(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fake_spawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x086e29df(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]]] = {
0xd438739d: ('spawn_delay', _decode_spawn_delay),
0xb1351a96: ('unknown_0xb1351a96', _decode_unknown_0xb1351a96),
0xa37429ee: ('spawn_hazard_time', _decode_spawn_hazard_time),
0x40ae4a09: ('flip_time', _decode_flip_time),
0x97473dac: ('medium_idle_time', _decode_medium_idle_time),
0x2e312774: ('long_idle_time', _decode_long_idle_time),
0x7850d13c: ('unknown_0x7850d13c', _decode_unknown_0x7850d13c),
0xde1a7739: ('unknown_0xde1a7739', _decode_unknown_0xde1a7739),
0xeddfb002: ('unknown_0xeddfb002', _decode_unknown_0xeddfb002),
0x62ca4939: ('unknown_0x62ca4939', _decode_unknown_0x62ca4939),
0x84d9331a: ('fake_spawn_delay', _decode_fake_spawn_delay),
0x86e29df: ('unknown_0x086e29df', _decode_unknown_0x086e29df),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct239.py | 0.63624 | 0.295459 | UnknownStruct239.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 UnknownStruct87(BaseProperty):
flip_duration: float = dataclasses.field(default=3.0)
unknown_0xf5fa970d: float = dataclasses.field(default=3.0)
unknown_0x14044489: float = dataclasses.field(default=0.33000001311302185)
struggle_duration: 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\x04') # 4 properties
data.write(b'\xf7\xf88z') # 0xf7f8387a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flip_duration))
data.write(b'\xf5\xfa\x97\r') # 0xf5fa970d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf5fa970d))
data.write(b'\x14\x04D\x89') # 0x14044489
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x14044489))
data.write(b'9\x87\r5') # 0x39870d35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.struggle_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
flip_duration=data['flip_duration'],
unknown_0xf5fa970d=data['unknown_0xf5fa970d'],
unknown_0x14044489=data['unknown_0x14044489'],
struggle_duration=data['struggle_duration'],
)
def to_json(self) -> dict:
return {
'flip_duration': self.flip_duration,
'unknown_0xf5fa970d': self.unknown_0xf5fa970d,
'unknown_0x14044489': self.unknown_0x14044489,
'struggle_duration': self.struggle_duration,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf7f8387a, 0xf5fa970d, 0x14044489, 0x39870d35)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct87]:
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 UnknownStruct87(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_flip_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf5fa970d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x14044489(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_struggle_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]]] = {
0xf7f8387a: ('flip_duration', _decode_flip_duration),
0xf5fa970d: ('unknown_0xf5fa970d', _decode_unknown_0xf5fa970d),
0x14044489: ('unknown_0x14044489', _decode_unknown_0x14044489),
0x39870d35: ('struggle_duration', _decode_struggle_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct87.py | 0.628065 | 0.310969 | UnknownStruct87.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 UnknownStruct207(BaseProperty):
distance0: float = dataclasses.field(default=6.5)
distance1: float = dataclasses.field(default=9.0)
distance2: float = dataclasses.field(default=13.5)
distance3: float = dataclasses.field(default=18.0)
distance4: float = dataclasses.field(default=20.0)
distance5: float = dataclasses.field(default=27.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'\xc4\x8b\x03V') # 0xc48b0356
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance0))
data.write(b'\x0f\xd7\xd0\xf3') # 0xfd7d0f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance1))
data.write(b'\x89C\xa2]') # 0x8943a25d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance2))
data.write(b'B\x1fq\xf8') # 0x421f71f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance3))
data.write(b'_\x1aA@') # 0x5f1a4140
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance4))
data.write(b'\x94F\x92\xe5') # 0x944692e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance5))
@classmethod
def from_json(cls, data: dict):
return cls(
distance0=data['distance0'],
distance1=data['distance1'],
distance2=data['distance2'],
distance3=data['distance3'],
distance4=data['distance4'],
distance5=data['distance5'],
)
def to_json(self) -> dict:
return {
'distance0': self.distance0,
'distance1': self.distance1,
'distance2': self.distance2,
'distance3': self.distance3,
'distance4': self.distance4,
'distance5': self.distance5,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc48b0356, 0xfd7d0f3, 0x8943a25d, 0x421f71f8, 0x5f1a4140, 0x944692e5)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct207]:
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 UnknownStruct207(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_distance0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance5(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]]] = {
0xc48b0356: ('distance0', _decode_distance0),
0xfd7d0f3: ('distance1', _decode_distance1),
0x8943a25d: ('distance2', _decode_distance2),
0x421f71f8: ('distance3', _decode_distance3),
0x5f1a4140: ('distance4', _decode_distance4),
0x944692e5: ('distance5', _decode_distance5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct207.py | 0.658857 | 0.374705 | UnknownStruct207.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.UnknownStruct154 import UnknownStruct154
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct155 import UnknownStruct155
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 UnknownStruct156(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
title_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
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)
continue_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
core_continue_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
retry_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
core_retry_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
retry_confirm_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x8ae3361b: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x8416a311: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct154: UnknownStruct154 = dataclasses.field(default_factory=UnknownStruct154)
unknown_struct155: UnknownStruct155 = dataclasses.field(default_factory=UnknownStruct155)
unknown_struct26_0x860139ad: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x6a598a9b: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x3be205da: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x96cd80d1: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\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'\xef\xc5\xa17') # 0xefc5a137
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title_text))
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"\x1f['\x1d") # 0x1f5b271d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.continue_text))
data.write(b'D\x9fRu') # 0x449f5275
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.core_continue_text))
data.write(b'L\xaf\xdd\xd1') # 0x4cafddd1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.retry_text))
data.write(b'6\x1c\xcf\x90') # 0x361ccf90
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.core_retry_text))
data.write(b'J\\\xb6\xef') # 0x4a5cb6ef
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.retry_confirm_text))
data.write(b'\x8a\xe36\x1b') # 0x8ae3361b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x8ae3361b))
data.write(b'\x84\x16\xa3\x11') # 0x8416a311
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x8416a311))
data.write(b'\xf0\xa3\x97\x8e') # 0xf0a3978e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct154.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0b\xdeR\x16') # 0xbde5216
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct155.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\x019\xad') # 0x860139ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x860139ad.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'jY\x8a\x9b') # 0x6a598a9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x6a598a9b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\xe2\x05\xda') # 0x3be205da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x3be205da.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x96\xcd\x80\xd1') # 0x96cd80d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x96cd80d1.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(
gui_frame=data['gui_frame'],
title_text=data['title_text'],
unlock_concept_art=data['unlock_concept_art'],
unlock_music=data['unlock_music'],
unlock_diorama=data['unlock_diorama'],
continue_text=data['continue_text'],
core_continue_text=data['core_continue_text'],
retry_text=data['retry_text'],
core_retry_text=data['core_retry_text'],
retry_confirm_text=data['retry_confirm_text'],
strg_0x8ae3361b=data['strg_0x8ae3361b'],
strg_0x8416a311=data['strg_0x8416a311'],
unknown_struct154=UnknownStruct154.from_json(data['unknown_struct154']),
unknown_struct155=UnknownStruct155.from_json(data['unknown_struct155']),
unknown_struct26_0x860139ad=UnknownStruct26.from_json(data['unknown_struct26_0x860139ad']),
unknown_struct26_0x6a598a9b=UnknownStruct26.from_json(data['unknown_struct26_0x6a598a9b']),
unknown_struct26_0x3be205da=UnknownStruct26.from_json(data['unknown_struct26_0x3be205da']),
unknown_struct26_0x96cd80d1=UnknownStruct26.from_json(data['unknown_struct26_0x96cd80d1']),
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'title_text': self.title_text,
'unlock_concept_art': self.unlock_concept_art,
'unlock_music': self.unlock_music,
'unlock_diorama': self.unlock_diorama,
'continue_text': self.continue_text,
'core_continue_text': self.core_continue_text,
'retry_text': self.retry_text,
'core_retry_text': self.core_retry_text,
'retry_confirm_text': self.retry_confirm_text,
'strg_0x8ae3361b': self.strg_0x8ae3361b,
'strg_0x8416a311': self.strg_0x8416a311,
'unknown_struct154': self.unknown_struct154.to_json(),
'unknown_struct155': self.unknown_struct155.to_json(),
'unknown_struct26_0x860139ad': self.unknown_struct26_0x860139ad.to_json(),
'unknown_struct26_0x6a598a9b': self.unknown_struct26_0x6a598a9b.to_json(),
'unknown_struct26_0x3be205da': self.unknown_struct26_0x3be205da.to_json(),
'unknown_struct26_0x96cd80d1': self.unknown_struct26_0x96cd80d1.to_json(),
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_title_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
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_continue_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_core_continue_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_retry_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_core_retry_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_retry_confirm_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x8ae3361b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x8416a311(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct154(data: typing.BinaryIO, property_size: int):
return UnknownStruct154.from_stream(data, property_size)
def _decode_unknown_struct155(data: typing.BinaryIO, property_size: int):
return UnknownStruct155.from_stream(data, property_size)
def _decode_unknown_struct26_0x860139ad(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x6a598a9b(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x3be205da(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x96cd80d1(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0xefc5a137: ('title_text', _decode_title_text),
0x79589bf4: ('unlock_concept_art', _decode_unlock_concept_art),
0xaf707df: ('unlock_music', _decode_unlock_music),
0x5ce2a9a9: ('unlock_diorama', _decode_unlock_diorama),
0x1f5b271d: ('continue_text', _decode_continue_text),
0x449f5275: ('core_continue_text', _decode_core_continue_text),
0x4cafddd1: ('retry_text', _decode_retry_text),
0x361ccf90: ('core_retry_text', _decode_core_retry_text),
0x4a5cb6ef: ('retry_confirm_text', _decode_retry_confirm_text),
0x8ae3361b: ('strg_0x8ae3361b', _decode_strg_0x8ae3361b),
0x8416a311: ('strg_0x8416a311', _decode_strg_0x8416a311),
0xf0a3978e: ('unknown_struct154', _decode_unknown_struct154),
0xbde5216: ('unknown_struct155', _decode_unknown_struct155),
0x860139ad: ('unknown_struct26_0x860139ad', _decode_unknown_struct26_0x860139ad),
0x6a598a9b: ('unknown_struct26_0x6a598a9b', _decode_unknown_struct26_0x6a598a9b),
0x3be205da: ('unknown_struct26_0x3be205da', _decode_unknown_struct26_0x3be205da),
0x96cd80d1: ('unknown_struct26_0x96cd80d1', _decode_unknown_struct26_0x96cd80d1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct156.py | 0.513181 | 0.167559 | UnknownStruct156.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.SuspensionBridgeStruct import SuspensionBridgeStruct
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct269 import UnknownStruct269
@dataclasses.dataclass()
class SuspensionBridgeData(BaseProperty):
unknown_0x0e4c8a24: bool = dataclasses.field(default=False)
unknown_0x7b5d0e29: float = dataclasses.field(default=5.0)
unknown_0x06df8bd9: float = dataclasses.field(default=12.0)
unknown_0xda13807d: float = dataclasses.field(default=20.0)
unknown_struct269: UnknownStruct269 = dataclasses.field(default_factory=UnknownStruct269)
suspension_bridge_struct_0xf6555670: SuspensionBridgeStruct = dataclasses.field(default_factory=SuspensionBridgeStruct)
suspension_bridge_struct_0x7cb2693b: SuspensionBridgeStruct = dataclasses.field(default_factory=SuspensionBridgeStruct)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x0eL\x8a$') # 0xe4c8a24
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0e4c8a24))
data.write(b'{]\x0e)') # 0x7b5d0e29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7b5d0e29))
data.write(b'\x06\xdf\x8b\xd9') # 0x6df8bd9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x06df8bd9))
data.write(b'\xda\x13\x80}') # 0xda13807d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xda13807d))
data.write(b'h\x1fLv') # 0x681f4c76
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct269.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf6UVp') # 0xf6555670
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.suspension_bridge_struct_0xf6555670.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|\xb2i;') # 0x7cb2693b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.suspension_bridge_struct_0x7cb2693b.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_0x0e4c8a24=data['unknown_0x0e4c8a24'],
unknown_0x7b5d0e29=data['unknown_0x7b5d0e29'],
unknown_0x06df8bd9=data['unknown_0x06df8bd9'],
unknown_0xda13807d=data['unknown_0xda13807d'],
unknown_struct269=UnknownStruct269.from_json(data['unknown_struct269']),
suspension_bridge_struct_0xf6555670=SuspensionBridgeStruct.from_json(data['suspension_bridge_struct_0xf6555670']),
suspension_bridge_struct_0x7cb2693b=SuspensionBridgeStruct.from_json(data['suspension_bridge_struct_0x7cb2693b']),
)
def to_json(self) -> dict:
return {
'unknown_0x0e4c8a24': self.unknown_0x0e4c8a24,
'unknown_0x7b5d0e29': self.unknown_0x7b5d0e29,
'unknown_0x06df8bd9': self.unknown_0x06df8bd9,
'unknown_0xda13807d': self.unknown_0xda13807d,
'unknown_struct269': self.unknown_struct269.to_json(),
'suspension_bridge_struct_0xf6555670': self.suspension_bridge_struct_0xf6555670.to_json(),
'suspension_bridge_struct_0x7cb2693b': self.suspension_bridge_struct_0x7cb2693b.to_json(),
}
def _decode_unknown_0x0e4c8a24(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7b5d0e29(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x06df8bd9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xda13807d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct269(data: typing.BinaryIO, property_size: int):
return UnknownStruct269.from_stream(data, property_size)
def _decode_suspension_bridge_struct_0xf6555670(data: typing.BinaryIO, property_size: int):
return SuspensionBridgeStruct.from_stream(data, property_size)
def _decode_suspension_bridge_struct_0x7cb2693b(data: typing.BinaryIO, property_size: int):
return SuspensionBridgeStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe4c8a24: ('unknown_0x0e4c8a24', _decode_unknown_0x0e4c8a24),
0x7b5d0e29: ('unknown_0x7b5d0e29', _decode_unknown_0x7b5d0e29),
0x6df8bd9: ('unknown_0x06df8bd9', _decode_unknown_0x06df8bd9),
0xda13807d: ('unknown_0xda13807d', _decode_unknown_0xda13807d),
0x681f4c76: ('unknown_struct269', _decode_unknown_struct269),
0xf6555670: ('suspension_bridge_struct_0xf6555670', _decode_suspension_bridge_struct_0xf6555670),
0x7cb2693b: ('suspension_bridge_struct_0x7cb2693b', _decode_suspension_bridge_struct_0x7cb2693b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SuspensionBridgeData.py | 0.615435 | 0.278577 | SuspensionBridgeData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct200(BaseProperty):
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
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\x02') # 2 properties
data.write(b' \t\x1bT') # 0x20091b54
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'\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(
spline_type=SplineType.from_json(data['spline_type']),
velocity=Spline.from_json(data['velocity']),
)
def to_json(self) -> dict:
return {
'spline_type': self.spline_type.to_json(),
'velocity': self.velocity.to_json(),
}
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
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]]] = {
0x20091b54: ('spline_type', _decode_spline_type),
0x13eb5a7d: ('velocity', _decode_velocity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct200.py | 0.621541 | 0.312396 | UnknownStruct200.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.UnknownStruct52 import UnknownStruct52
@dataclasses.dataclass()
class UnknownStruct186(BaseProperty):
unknown_0x8a58a7f8: int = dataclasses.field(default=1)
unknown_0xa9ac7ded: float = dataclasses.field(default=2.0)
unknown_struct52_0x17a93807: UnknownStruct52 = dataclasses.field(default_factory=UnknownStruct52)
unknown_struct52_0x8c219932: UnknownStruct52 = dataclasses.field(default_factory=UnknownStruct52)
@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'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'\xa9\xac}\xed') # 0xa9ac7ded
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa9ac7ded))
data.write(b'\x17\xa98\x07') # 0x17a93807
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct52_0x17a93807.to_stream(data, default_override={'distance': 4.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c!\x992') # 0x8c219932
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct52_0x8c219932.to_stream(data, default_override={'distance': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
unknown_0xa9ac7ded=data['unknown_0xa9ac7ded'],
unknown_struct52_0x17a93807=UnknownStruct52.from_json(data['unknown_struct52_0x17a93807']),
unknown_struct52_0x8c219932=UnknownStruct52.from_json(data['unknown_struct52_0x8c219932']),
)
def to_json(self) -> dict:
return {
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'unknown_0xa9ac7ded': self.unknown_0xa9ac7ded,
'unknown_struct52_0x17a93807': self.unknown_struct52_0x17a93807.to_json(),
'unknown_struct52_0x8c219932': self.unknown_struct52_0x8c219932.to_json(),
}
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xa9ac7ded(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct52_0x17a93807(data: typing.BinaryIO, property_size: int):
return UnknownStruct52.from_stream(data, property_size, default_override={'distance': 4.0})
def _decode_unknown_struct52_0x8c219932(data: typing.BinaryIO, property_size: int):
return UnknownStruct52.from_stream(data, property_size, default_override={'distance': 5.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0xa9ac7ded: ('unknown_0xa9ac7ded', _decode_unknown_0xa9ac7ded),
0x17a93807: ('unknown_struct52_0x17a93807', _decode_unknown_struct52_0x17a93807),
0x8c219932: ('unknown_struct52_0x8c219932', _decode_unknown_struct52_0x8c219932),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct186.py | 0.613584 | 0.214753 | UnknownStruct186.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 SwoopBehaviorData(BaseProperty):
unknown_0x23057384: bool = dataclasses.field(default=True)
unknown_0x875d59f9: bool = dataclasses.field(default=False)
swoop_towards_target: bool = dataclasses.field(default=False)
unknown_0xc7a07e1c: bool = dataclasses.field(default=False)
unknown_0x18c4d552: float = dataclasses.field(default=1.0)
unknown_0x3ce63601: float = dataclasses.field(default=6.0)
unknown_0xcdf6ebf3: float = dataclasses.field(default=6.0)
unknown_0x80842977: float = dataclasses.field(default=0.0)
unknown_0x8910e24c: float = dataclasses.field(default=20.0)
drop: float = dataclasses.field(default=5.0)
unknown_0x5974d648: float = dataclasses.field(default=10.0)
unknown_0x00c3f023: float = dataclasses.field(default=3.0)
unknown_0xdcfa472a: float = dataclasses.field(default=3.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\r') # 13 properties
data.write(b'#\x05s\x84') # 0x23057384
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x23057384))
data.write(b'\x87]Y\xf9') # 0x875d59f9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x875d59f9))
data.write(b'\x11\xf7(\xa1') # 0x11f728a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.swoop_towards_target))
data.write(b'\xc7\xa0~\x1c') # 0xc7a07e1c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc7a07e1c))
data.write(b'\x18\xc4\xd5R') # 0x18c4d552
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x18c4d552))
data.write(b'<\xe66\x01') # 0x3ce63601
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3ce63601))
data.write(b'\xcd\xf6\xeb\xf3') # 0xcdf6ebf3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcdf6ebf3))
data.write(b'\x80\x84)w') # 0x80842977
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x80842977))
data.write(b'\x89\x10\xe2L') # 0x8910e24c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8910e24c))
data.write(b'\r\xa6\xb7\xf2') # 0xda6b7f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drop))
data.write(b'Yt\xd6H') # 0x5974d648
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5974d648))
data.write(b'\x00\xc3\xf0#') # 0xc3f023
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x00c3f023))
data.write(b'\xdc\xfaG*') # 0xdcfa472a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xdcfa472a))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x23057384=data['unknown_0x23057384'],
unknown_0x875d59f9=data['unknown_0x875d59f9'],
swoop_towards_target=data['swoop_towards_target'],
unknown_0xc7a07e1c=data['unknown_0xc7a07e1c'],
unknown_0x18c4d552=data['unknown_0x18c4d552'],
unknown_0x3ce63601=data['unknown_0x3ce63601'],
unknown_0xcdf6ebf3=data['unknown_0xcdf6ebf3'],
unknown_0x80842977=data['unknown_0x80842977'],
unknown_0x8910e24c=data['unknown_0x8910e24c'],
drop=data['drop'],
unknown_0x5974d648=data['unknown_0x5974d648'],
unknown_0x00c3f023=data['unknown_0x00c3f023'],
unknown_0xdcfa472a=data['unknown_0xdcfa472a'],
)
def to_json(self) -> dict:
return {
'unknown_0x23057384': self.unknown_0x23057384,
'unknown_0x875d59f9': self.unknown_0x875d59f9,
'swoop_towards_target': self.swoop_towards_target,
'unknown_0xc7a07e1c': self.unknown_0xc7a07e1c,
'unknown_0x18c4d552': self.unknown_0x18c4d552,
'unknown_0x3ce63601': self.unknown_0x3ce63601,
'unknown_0xcdf6ebf3': self.unknown_0xcdf6ebf3,
'unknown_0x80842977': self.unknown_0x80842977,
'unknown_0x8910e24c': self.unknown_0x8910e24c,
'drop': self.drop,
'unknown_0x5974d648': self.unknown_0x5974d648,
'unknown_0x00c3f023': self.unknown_0x00c3f023,
'unknown_0xdcfa472a': self.unknown_0xdcfa472a,
}
_FAST_FORMAT = None
_FAST_IDS = (0x23057384, 0x875d59f9, 0x11f728a1, 0xc7a07e1c, 0x18c4d552, 0x3ce63601, 0xcdf6ebf3, 0x80842977, 0x8910e24c, 0xda6b7f2, 0x5974d648, 0xc3f023, 0xdcfa472a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SwoopBehaviorData]:
if property_count != 13:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(118))
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]) != _FAST_IDS:
data.seek(before)
return None
return SwoopBehaviorData(
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],
)
def _decode_unknown_0x23057384(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x875d59f9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_swoop_towards_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xc7a07e1c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x18c4d552(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3ce63601(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcdf6ebf3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x80842977(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8910e24c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5974d648(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x00c3f023(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xdcfa472a(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]]] = {
0x23057384: ('unknown_0x23057384', _decode_unknown_0x23057384),
0x875d59f9: ('unknown_0x875d59f9', _decode_unknown_0x875d59f9),
0x11f728a1: ('swoop_towards_target', _decode_swoop_towards_target),
0xc7a07e1c: ('unknown_0xc7a07e1c', _decode_unknown_0xc7a07e1c),
0x18c4d552: ('unknown_0x18c4d552', _decode_unknown_0x18c4d552),
0x3ce63601: ('unknown_0x3ce63601', _decode_unknown_0x3ce63601),
0xcdf6ebf3: ('unknown_0xcdf6ebf3', _decode_unknown_0xcdf6ebf3),
0x80842977: ('unknown_0x80842977', _decode_unknown_0x80842977),
0x8910e24c: ('unknown_0x8910e24c', _decode_unknown_0x8910e24c),
0xda6b7f2: ('drop', _decode_drop),
0x5974d648: ('unknown_0x5974d648', _decode_unknown_0x5974d648),
0xc3f023: ('unknown_0x00c3f023', _decode_unknown_0x00c3f023),
0xdcfa472a: ('unknown_0xdcfa472a', _decode_unknown_0xdcfa472a),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SwoopBehaviorData.py | 0.636692 | 0.292469 | SwoopBehaviorData.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 PIDConvergence(BaseProperty):
pid_type: enums.PIDType = dataclasses.field(default=enums.PIDType.Unknown2)
k_p: float = dataclasses.field(default=0.0)
k_i: float = dataclasses.field(default=0.0)
k_d: float = dataclasses.field(default=0.0)
threshold: 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\x05') # 5 properties
data.write(b'\xd0\x81\x01#') # 0xd0810123
data.write(b'\x00\x04') # size
self.pid_type.to_stream(data)
data.write(b'\xe8+\x99\xe1') # 0xe82b99e1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.k_p))
data.write(b'\xcc\xf2\xca\xb2') # 0xccf2cab2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.k_i))
data.write(b'pl\xd9l') # 0x706cd96c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.k_d))
data.write(b'\x8e\x1b\x83\xf9') # 0x8e1b83f9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.threshold))
@classmethod
def from_json(cls, data: dict):
return cls(
pid_type=enums.PIDType.from_json(data['pid_type']),
k_p=data['k_p'],
k_i=data['k_i'],
k_d=data['k_d'],
threshold=data['threshold'],
)
def to_json(self) -> dict:
return {
'pid_type': self.pid_type.to_json(),
'k_p': self.k_p,
'k_i': self.k_i,
'k_d': self.k_d,
'threshold': self.threshold,
}
_FAST_FORMAT = None
_FAST_IDS = (0xd0810123, 0xe82b99e1, 0xccf2cab2, 0x706cd96c, 0x8e1b83f9)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PIDConvergence]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(50))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return PIDConvergence(
enums.PIDType(dec[2]),
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_pid_type(data: typing.BinaryIO, property_size: int):
return enums.PIDType.from_stream(data)
def _decode_k_p(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_k_i(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_k_d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd0810123: ('pid_type', _decode_pid_type),
0xe82b99e1: ('k_p', _decode_k_p),
0xccf2cab2: ('k_i', _decode_k_i),
0x706cd96c: ('k_d', _decode_k_d),
0x8e1b83f9: ('threshold', _decode_threshold),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PIDConvergence.py | 0.644784 | 0.307416 | PIDConvergence.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 OptionalAreaAssetTypes(BaseProperty):
unknown: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'[\xfe\x12\x8f') # 0x5bfe128f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', 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 = (0x5bfe128f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[OptionalAreaAssetTypes]:
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 OptionalAreaAssetTypes(
dec[2],
)
def _decode_unknown(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]]] = {
0x5bfe128f: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OptionalAreaAssetTypes.py | 0.711832 | 0.29432 | OptionalAreaAssetTypes.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 InterpolationMethod(BaseProperty):
interpolation_control_type: enums.InterpolationControlType = dataclasses.field(default=enums.InterpolationControlType.Unknown2)
control_spline: Spline = dataclasses.field(default_factory=Spline)
ease_in: float = dataclasses.field(default=0.25)
ease_out: float = dataclasses.field(default=0.75)
duration: 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\x05') # 5 properties
data.write(b'\t\xb5\x95}') # 0x9b5957d
data.write(b'\x00\x04') # size
self.interpolation_control_type.to_stream(data)
data.write(b'\x15V\x7f\xe7') # 0x15567fe7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'\xb0\x8d27') # 0xb08d3237
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ease_in))
data.write(b'g\xe3\x83j') # 0x67e3836a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ease_out))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
@classmethod
def from_json(cls, data: dict):
return cls(
interpolation_control_type=enums.InterpolationControlType.from_json(data['interpolation_control_type']),
control_spline=Spline.from_json(data['control_spline']),
ease_in=data['ease_in'],
ease_out=data['ease_out'],
duration=data['duration'],
)
def to_json(self) -> dict:
return {
'interpolation_control_type': self.interpolation_control_type.to_json(),
'control_spline': self.control_spline.to_json(),
'ease_in': self.ease_in,
'ease_out': self.ease_out,
'duration': self.duration,
}
def _decode_interpolation_control_type(data: typing.BinaryIO, property_size: int):
return enums.InterpolationControlType.from_stream(data)
def _decode_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_ease_in(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ease_out(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x9b5957d: ('interpolation_control_type', _decode_interpolation_control_type),
0x15567fe7: ('control_spline', _decode_control_spline),
0xb08d3237: ('ease_in', _decode_ease_in),
0x67e3836a: ('ease_out', _decode_ease_out),
0x8b51e23f: ('duration', _decode_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/InterpolationMethod.py | 0.67822 | 0.302121 | InterpolationMethod.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.UnknownStruct293 import UnknownStruct293
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct294 import UnknownStruct294
@dataclasses.dataclass()
class UnknownStruct295(BaseProperty):
gravity: float = dataclasses.field(default=55.0)
unknown: float = dataclasses.field(default=0.5)
unknown_struct293: UnknownStruct293 = dataclasses.field(default_factory=UnknownStruct293)
unknown_struct294: UnknownStruct294 = dataclasses.field(default_factory=UnknownStruct294)
@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'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xee8&Q') # 0xee382651
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xa9\xb9\x99\x7f') # 0xa9b9997f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct293.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~;1\x84') # 0x7e3b3184
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct294.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
gravity=data['gravity'],
unknown=data['unknown'],
unknown_struct293=UnknownStruct293.from_json(data['unknown_struct293']),
unknown_struct294=UnknownStruct294.from_json(data['unknown_struct294']),
)
def to_json(self) -> dict:
return {
'gravity': self.gravity,
'unknown': self.unknown,
'unknown_struct293': self.unknown_struct293.to_json(),
'unknown_struct294': self.unknown_struct294.to_json(),
}
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct293(data: typing.BinaryIO, property_size: int):
return UnknownStruct293.from_stream(data, property_size)
def _decode_unknown_struct294(data: typing.BinaryIO, property_size: int):
return UnknownStruct294.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f2ae3e5: ('gravity', _decode_gravity),
0xee382651: ('unknown', _decode_unknown),
0xa9b9997f: ('unknown_struct293', _decode_unknown_struct293),
0x7e3b3184: ('unknown_struct294', _decode_unknown_struct294),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct295.py | 0.633637 | 0.305801 | UnknownStruct295.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 UnknownStruct510(BaseProperty):
shadow_projection: enums.ShadowProjection = dataclasses.field(default=enums.ShadowProjection.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'KBJ9') # 0x4b424a39
data.write(b'\x00\x04') # size
self.shadow_projection.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
shadow_projection=enums.ShadowProjection.from_json(data['shadow_projection']),
)
def to_json(self) -> dict:
return {
'shadow_projection': self.shadow_projection.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x4b424a39)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct510]:
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 UnknownStruct510(
enums.ShadowProjection(dec[2]),
)
def _decode_shadow_projection(data: typing.BinaryIO, property_size: int):
return enums.ShadowProjection.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4b424a39: ('shadow_projection', _decode_shadow_projection),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct510.py | 0.62681 | 0.276538 | UnknownStruct510.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.PIDConvergence import PIDConvergence
from retro_data_structures.properties.dkc_returns.archetypes.ProportionalConvergence import ProportionalConvergence
from retro_data_structures.properties.dkc_returns.archetypes.SpringConvergence import SpringConvergence
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct66 import UnknownStruct66
from retro_data_structures.properties.dkc_returns.archetypes.VelocityConvergence import VelocityConvergence
@dataclasses.dataclass()
class Convergence(BaseProperty):
convergence_type: enums.ConvergenceType = dataclasses.field(default=enums.ConvergenceType.Unknown4)
velocity: VelocityConvergence = dataclasses.field(default_factory=VelocityConvergence)
unknown_struct66: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
spring: SpringConvergence = dataclasses.field(default_factory=SpringConvergence)
pid: PIDConvergence = dataclasses.field(default_factory=PIDConvergence)
proportional: ProportionalConvergence = dataclasses.field(default_factory=ProportionalConvergence)
@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'.\xf2$\x01') # 0x2ef22401
data.write(b'\x00\x04') # size
self.convergence_type.to_stream(data)
data.write(b'o\x9d\x9b3') # 0x6f9d9b33
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)
data.write(b'\x1f\xf4}\xdf') # 0x1ff47ddf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct66.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0c\xf38\x16') # 0xcf33816
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spring.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\xe4\x02\xef') # 0xf9e402ef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pid.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x08VH\xbc') # 0x85648bc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.proportional.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(
convergence_type=enums.ConvergenceType.from_json(data['convergence_type']),
velocity=VelocityConvergence.from_json(data['velocity']),
unknown_struct66=UnknownStruct66.from_json(data['unknown_struct66']),
spring=SpringConvergence.from_json(data['spring']),
pid=PIDConvergence.from_json(data['pid']),
proportional=ProportionalConvergence.from_json(data['proportional']),
)
def to_json(self) -> dict:
return {
'convergence_type': self.convergence_type.to_json(),
'velocity': self.velocity.to_json(),
'unknown_struct66': self.unknown_struct66.to_json(),
'spring': self.spring.to_json(),
'pid': self.pid.to_json(),
'proportional': self.proportional.to_json(),
}
def _decode_convergence_type(data: typing.BinaryIO, property_size: int):
return enums.ConvergenceType.from_stream(data)
def _decode_velocity(data: typing.BinaryIO, property_size: int):
return VelocityConvergence.from_stream(data, property_size)
def _decode_unknown_struct66(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_spring(data: typing.BinaryIO, property_size: int):
return SpringConvergence.from_stream(data, property_size)
def _decode_pid(data: typing.BinaryIO, property_size: int):
return PIDConvergence.from_stream(data, property_size)
def _decode_proportional(data: typing.BinaryIO, property_size: int):
return ProportionalConvergence.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2ef22401: ('convergence_type', _decode_convergence_type),
0x6f9d9b33: ('velocity', _decode_velocity),
0x1ff47ddf: ('unknown_struct66', _decode_unknown_struct66),
0xcf33816: ('spring', _decode_spring),
0xf9e402ef: ('pid', _decode_pid),
0x85648bc: ('proportional', _decode_proportional),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/Convergence.py | 0.61451 | 0.268216 | Convergence.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 UnknownStruct287(BaseProperty):
body_part: enums.BodyPart = dataclasses.field(default=enums.BodyPart.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'\x02\xf7\x8c\x9a') # 0x2f78c9a
data.write(b'\x00\x04') # size
self.body_part.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
body_part=enums.BodyPart.from_json(data['body_part']),
)
def to_json(self) -> dict:
return {
'body_part': self.body_part.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x2f78c9a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct287]:
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 UnknownStruct287(
enums.BodyPart(dec[2]),
)
def _decode_body_part(data: typing.BinaryIO, property_size: int):
return enums.BodyPart.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f78c9a: ('body_part', _decode_body_part),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct287.py | 0.621541 | 0.298485 | UnknownStruct287.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerType import PlayerType
@dataclasses.dataclass()
class PlayerMountRiderData(BaseProperty):
character_type: PlayerType = dataclasses.field(default_factory=PlayerType)
mount_locator: str = dataclasses.field(default='')
alternate_mount_locator: str = dataclasses.field(default='')
allow_butt_slap_interaction: bool = dataclasses.field(default=False)
allow_grab_detach: bool = dataclasses.field(default=False)
allow_crouch: bool = dataclasses.field(default=False)
generate_arc_motion: bool = dataclasses.field(default=True)
struggle_turn_priority: int = dataclasses.field(default=1)
optional_lerp_duration: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x01>5\xfb') # 0x13e35fb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\xf9R\xbd') # 0xe7f952bd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.mount_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'\xb0\xf7\x959') # 0xb0f79539
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.alternate_mount_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'j\x1b\xa6o') # 0x6a1ba66f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_butt_slap_interaction))
data.write(b'\x1a.cr') # 0x1a2e6372
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_grab_detach))
data.write(b"\xab6'\xb8") # 0xab3627b8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_crouch))
data.write(b'l\xdf\x86\x83') # 0x6cdf8683
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.generate_arc_motion))
data.write(b'E\xe4KN') # 0x45e44b4e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.struggle_turn_priority))
data.write(b'\xe8)\x96\x9a') # 0xe829969a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.optional_lerp_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
character_type=PlayerType.from_json(data['character_type']),
mount_locator=data['mount_locator'],
alternate_mount_locator=data['alternate_mount_locator'],
allow_butt_slap_interaction=data['allow_butt_slap_interaction'],
allow_grab_detach=data['allow_grab_detach'],
allow_crouch=data['allow_crouch'],
generate_arc_motion=data['generate_arc_motion'],
struggle_turn_priority=data['struggle_turn_priority'],
optional_lerp_duration=data['optional_lerp_duration'],
)
def to_json(self) -> dict:
return {
'character_type': self.character_type.to_json(),
'mount_locator': self.mount_locator,
'alternate_mount_locator': self.alternate_mount_locator,
'allow_butt_slap_interaction': self.allow_butt_slap_interaction,
'allow_grab_detach': self.allow_grab_detach,
'allow_crouch': self.allow_crouch,
'generate_arc_motion': self.generate_arc_motion,
'struggle_turn_priority': self.struggle_turn_priority,
'optional_lerp_duration': self.optional_lerp_duration,
}
def _decode_character_type(data: typing.BinaryIO, property_size: int):
return PlayerType.from_stream(data, property_size)
def _decode_mount_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_alternate_mount_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_allow_butt_slap_interaction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_grab_detach(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_crouch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_generate_arc_motion(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_struggle_turn_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_optional_lerp_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]]] = {
0x13e35fb: ('character_type', _decode_character_type),
0xe7f952bd: ('mount_locator', _decode_mount_locator),
0xb0f79539: ('alternate_mount_locator', _decode_alternate_mount_locator),
0x6a1ba66f: ('allow_butt_slap_interaction', _decode_allow_butt_slap_interaction),
0x1a2e6372: ('allow_grab_detach', _decode_allow_grab_detach),
0xab3627b8: ('allow_crouch', _decode_allow_crouch),
0x6cdf8683: ('generate_arc_motion', _decode_generate_arc_motion),
0x45e44b4e: ('struggle_turn_priority', _decode_struggle_turn_priority),
0xe829969a: ('optional_lerp_duration', _decode_optional_lerp_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMountRiderData.py | 0.593256 | 0.277042 | PlayerMountRiderData.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 UnknownStruct(BaseProperty):
unknown: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'+;;}') # 0x2b3b3b7d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", 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 = (0x2b3b3b7d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct]:
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 UnknownStruct(
dec[2],
)
def _decode_unknown(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]]] = {
0x2b3b3b7d: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct.py | 0.630002 | 0.258192 | UnknownStruct.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 UnknownStruct36(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)
caud: 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\x03') # 3 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))
data.write(b'\xd0\x1e\xaeu') # 0xd01eae75
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
cine_lever=data['cine_lever'],
caud=data['caud'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'cine_lever': self.cine_lever,
'caud': self.caud,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe0c67593, 0xd9bed8d3, 0xd01eae75)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct36]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(42))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct36(
dec[2],
dec[5],
dec[8],
)
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]
def _decode_caud(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),
0xd01eae75: ('caud', _decode_caud),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct36.py | 0.608012 | 0.237443 | UnknownStruct36.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 FleeBehaviorData(BaseProperty):
flee_after_stunned: bool = dataclasses.field(default=False)
stop_fleeing_at_bounds: bool = dataclasses.field(default=True)
flee_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'|\x1eF[') # 0x7c1e465b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.flee_after_stunned))
data.write(b'\xdd\x07\x95F') # 0xdd079546
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stop_fleeing_at_bounds))
data.write(b'\x8b3\x92b') # 0x8b339262
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flee_time))
@classmethod
def from_json(cls, data: dict):
return cls(
flee_after_stunned=data['flee_after_stunned'],
stop_fleeing_at_bounds=data['stop_fleeing_at_bounds'],
flee_time=data['flee_time'],
)
def to_json(self) -> dict:
return {
'flee_after_stunned': self.flee_after_stunned,
'stop_fleeing_at_bounds': self.stop_fleeing_at_bounds,
'flee_time': self.flee_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0x7c1e465b, 0xdd079546, 0x8b339262)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FleeBehaviorData]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHf')
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 FleeBehaviorData(
dec[2],
dec[5],
dec[8],
)
def _decode_flee_after_stunned(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_stop_fleeing_at_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flee_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]]] = {
0x7c1e465b: ('flee_after_stunned', _decode_flee_after_stunned),
0xdd079546: ('stop_fleeing_at_bounds', _decode_stop_fleeing_at_bounds),
0x8b339262: ('flee_time', _decode_flee_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FleeBehaviorData.py | 0.61832 | 0.299227 | FleeBehaviorData.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 UnknownStruct189(BaseProperty):
unknown_0xe84a887b: float = dataclasses.field(default=1.0)
unknown_0x8a58a7f8: int = dataclasses.field(default=2)
stun_duration: 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\x03') # 3 properties
data.write(b'\xe8J\x88{') # 0xe84a887b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe84a887b))
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8a58a7f8))
data.write(b'-\x8d\xb3\x1d') # 0x2d8db31d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xe84a887b=data['unknown_0xe84a887b'],
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
stun_duration=data['stun_duration'],
)
def to_json(self) -> dict:
return {
'unknown_0xe84a887b': self.unknown_0xe84a887b,
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'stun_duration': self.stun_duration,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe84a887b, 0x8a58a7f8, 0x2d8db31d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct189]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHlLHf')
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 UnknownStruct189(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown_0xe84a887b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8a58a7f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_stun_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]]] = {
0xe84a887b: ('unknown_0xe84a887b', _decode_unknown_0xe84a887b),
0x8a58a7f8: ('unknown_0x8a58a7f8', _decode_unknown_0x8a58a7f8),
0x2d8db31d: ('stun_duration', _decode_stun_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct189.py | 0.620162 | 0.281094 | UnknownStruct189.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 MoleTrainManagerStructB(BaseProperty):
spawn_delay: float = dataclasses.field(default=1.0)
unknown_0xe1fac41a: int = dataclasses.field(default=33)
unknown_0xdaf59171: int = dataclasses.field(default=3)
unknown_0x2b846018: float = dataclasses.field(default=0.25)
unknown_0xa11b39c3: float = dataclasses.field(default=0.25)
flip_time: float = dataclasses.field(default=2.0)
idle_time: float = dataclasses.field(default=1.25)
unknown_0x3e5bab9d: float = dataclasses.field(default=-10.0)
hazard_cart_time: float = dataclasses.field(default=60.0)
unknown_0x552f8118: float = dataclasses.field(default=30.5)
unknown_0x86daba3b: float = dataclasses.field(default=20.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\xd48s\x9d') # 0xd438739d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.spawn_delay))
data.write(b'\xe1\xfa\xc4\x1a') # 0xe1fac41a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe1fac41a))
data.write(b'\xda\xf5\x91q') # 0xdaf59171
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xdaf59171))
data.write(b'+\x84`\x18') # 0x2b846018
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2b846018))
data.write(b'\xa1\x1b9\xc3') # 0xa11b39c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa11b39c3))
data.write(b'@\xaeJ\t') # 0x40ae4a09
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flip_time))
data.write(b'\xd1\x02\x0f,') # 0xd1020f2c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.idle_time))
data.write(b'>[\xab\x9d') # 0x3e5bab9d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3e5bab9d))
data.write(b'$D}\xc3') # 0x24447dc3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hazard_cart_time))
data.write(b'U/\x81\x18') # 0x552f8118
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x552f8118))
data.write(b'\x86\xda\xba;') # 0x86daba3b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x86daba3b))
@classmethod
def from_json(cls, data: dict):
return cls(
spawn_delay=data['spawn_delay'],
unknown_0xe1fac41a=data['unknown_0xe1fac41a'],
unknown_0xdaf59171=data['unknown_0xdaf59171'],
unknown_0x2b846018=data['unknown_0x2b846018'],
unknown_0xa11b39c3=data['unknown_0xa11b39c3'],
flip_time=data['flip_time'],
idle_time=data['idle_time'],
unknown_0x3e5bab9d=data['unknown_0x3e5bab9d'],
hazard_cart_time=data['hazard_cart_time'],
unknown_0x552f8118=data['unknown_0x552f8118'],
unknown_0x86daba3b=data['unknown_0x86daba3b'],
)
def to_json(self) -> dict:
return {
'spawn_delay': self.spawn_delay,
'unknown_0xe1fac41a': self.unknown_0xe1fac41a,
'unknown_0xdaf59171': self.unknown_0xdaf59171,
'unknown_0x2b846018': self.unknown_0x2b846018,
'unknown_0xa11b39c3': self.unknown_0xa11b39c3,
'flip_time': self.flip_time,
'idle_time': self.idle_time,
'unknown_0x3e5bab9d': self.unknown_0x3e5bab9d,
'hazard_cart_time': self.hazard_cart_time,
'unknown_0x552f8118': self.unknown_0x552f8118,
'unknown_0x86daba3b': self.unknown_0x86daba3b,
}
_FAST_FORMAT = None
_FAST_IDS = (0xd438739d, 0xe1fac41a, 0xdaf59171, 0x2b846018, 0xa11b39c3, 0x40ae4a09, 0xd1020f2c, 0x3e5bab9d, 0x24447dc3, 0x552f8118, 0x86daba3b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MoleTrainManagerStructB]:
if property_count != 11:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHlLHlLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(110))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30]) != _FAST_IDS:
data.seek(before)
return None
return MoleTrainManagerStructB(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
)
def _decode_spawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe1fac41a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xdaf59171(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2b846018(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa11b39c3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flip_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_idle_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3e5bab9d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hazard_cart_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x552f8118(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x86daba3b(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]]] = {
0xd438739d: ('spawn_delay', _decode_spawn_delay),
0xe1fac41a: ('unknown_0xe1fac41a', _decode_unknown_0xe1fac41a),
0xdaf59171: ('unknown_0xdaf59171', _decode_unknown_0xdaf59171),
0x2b846018: ('unknown_0x2b846018', _decode_unknown_0x2b846018),
0xa11b39c3: ('unknown_0xa11b39c3', _decode_unknown_0xa11b39c3),
0x40ae4a09: ('flip_time', _decode_flip_time),
0xd1020f2c: ('idle_time', _decode_idle_time),
0x3e5bab9d: ('unknown_0x3e5bab9d', _decode_unknown_0x3e5bab9d),
0x24447dc3: ('hazard_cart_time', _decode_hazard_cart_time),
0x552f8118: ('unknown_0x552f8118', _decode_unknown_0x552f8118),
0x86daba3b: ('unknown_0x86daba3b', _decode_unknown_0x86daba3b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MoleTrainManagerStructB.py | 0.605333 | 0.27907 | MoleTrainManagerStructB.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.UnknownStruct49 import UnknownStruct49
@dataclasses.dataclass()
class ForestBossStructB(BaseProperty):
unknown_0xc8844cea: float = dataclasses.field(default=10.0)
unknown_0x9f8a1ca9: float = dataclasses.field(default=30.0)
unknown_0x72fc2ebd: float = dataclasses.field(default=10.0)
tired_duration: float = dataclasses.field(default=8.0)
unknown_0x66b5bc1e: float = dataclasses.field(default=7.0)
unknown_0xe021ceb0: float = dataclasses.field(default=6.0)
unknown_0x2b7d1d15: float = dataclasses.field(default=5.0)
unknown_0xc4a217ad: float = dataclasses.field(default=0.10000000149011612)
unknown_struct49_0x84df6106: UnknownStruct49 = dataclasses.field(default_factory=UnknownStruct49)
unknown_struct49_0x9f91359a: UnknownStruct49 = dataclasses.field(default_factory=UnknownStruct49)
unknown_struct49_0x294bbca0: UnknownStruct49 = dataclasses.field(default_factory=UnknownStruct49)
flee_duration: float = dataclasses.field(default=20.0)
unknown_struct49_0x11c70370: UnknownStruct49 = dataclasses.field(default_factory=UnknownStruct49)
@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'\xc8\x84L\xea') # 0xc8844cea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc8844cea))
data.write(b'\x9f\x8a\x1c\xa9') # 0x9f8a1ca9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9f8a1ca9))
data.write(b'r\xfc.\xbd') # 0x72fc2ebd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72fc2ebd))
data.write(b'\xd2\xe5.}') # 0xd2e52e7d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tired_duration))
data.write(b'f\xb5\xbc\x1e') # 0x66b5bc1e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x66b5bc1e))
data.write(b'\xe0!\xce\xb0') # 0xe021ceb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe021ceb0))
data.write(b'+}\x1d\x15') # 0x2b7d1d15
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2b7d1d15))
data.write(b'\xc4\xa2\x17\xad') # 0xc4a217ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc4a217ad))
data.write(b'\x84\xdfa\x06') # 0x84df6106
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct49_0x84df6106.to_stream(data, default_override={'speed': 6.0, 'acceleration': 10.0, 'deceleration': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9f\x915\x9a') # 0x9f91359a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct49_0x9f91359a.to_stream(data, default_override={'acceleration': 10.0, 'deceleration': 10.0, 'roll_speed': 480.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b')K\xbc\xa0') # 0x294bbca0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct49_0x294bbca0.to_stream(data, default_override={'speed': 12.0, 'acceleration': 10.0, 'deceleration': 10.0, 'roll_speed': 180.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'P\x1c\xc3\x9f') # 0x501cc39f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flee_duration))
data.write(b'\x11\xc7\x03p') # 0x11c70370
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct49_0x11c70370.to_stream(data, default_override={'speed': 20.0, 'deceleration': 20.0, 'roll_speed': 180.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xc8844cea=data['unknown_0xc8844cea'],
unknown_0x9f8a1ca9=data['unknown_0x9f8a1ca9'],
unknown_0x72fc2ebd=data['unknown_0x72fc2ebd'],
tired_duration=data['tired_duration'],
unknown_0x66b5bc1e=data['unknown_0x66b5bc1e'],
unknown_0xe021ceb0=data['unknown_0xe021ceb0'],
unknown_0x2b7d1d15=data['unknown_0x2b7d1d15'],
unknown_0xc4a217ad=data['unknown_0xc4a217ad'],
unknown_struct49_0x84df6106=UnknownStruct49.from_json(data['unknown_struct49_0x84df6106']),
unknown_struct49_0x9f91359a=UnknownStruct49.from_json(data['unknown_struct49_0x9f91359a']),
unknown_struct49_0x294bbca0=UnknownStruct49.from_json(data['unknown_struct49_0x294bbca0']),
flee_duration=data['flee_duration'],
unknown_struct49_0x11c70370=UnknownStruct49.from_json(data['unknown_struct49_0x11c70370']),
)
def to_json(self) -> dict:
return {
'unknown_0xc8844cea': self.unknown_0xc8844cea,
'unknown_0x9f8a1ca9': self.unknown_0x9f8a1ca9,
'unknown_0x72fc2ebd': self.unknown_0x72fc2ebd,
'tired_duration': self.tired_duration,
'unknown_0x66b5bc1e': self.unknown_0x66b5bc1e,
'unknown_0xe021ceb0': self.unknown_0xe021ceb0,
'unknown_0x2b7d1d15': self.unknown_0x2b7d1d15,
'unknown_0xc4a217ad': self.unknown_0xc4a217ad,
'unknown_struct49_0x84df6106': self.unknown_struct49_0x84df6106.to_json(),
'unknown_struct49_0x9f91359a': self.unknown_struct49_0x9f91359a.to_json(),
'unknown_struct49_0x294bbca0': self.unknown_struct49_0x294bbca0.to_json(),
'flee_duration': self.flee_duration,
'unknown_struct49_0x11c70370': self.unknown_struct49_0x11c70370.to_json(),
}
def _decode_unknown_0xc8844cea(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9f8a1ca9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x72fc2ebd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tired_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x66b5bc1e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe021ceb0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2b7d1d15(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc4a217ad(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct49_0x84df6106(data: typing.BinaryIO, property_size: int):
return UnknownStruct49.from_stream(data, property_size, default_override={'speed': 6.0, 'acceleration': 10.0, 'deceleration': 10.0})
def _decode_unknown_struct49_0x9f91359a(data: typing.BinaryIO, property_size: int):
return UnknownStruct49.from_stream(data, property_size, default_override={'acceleration': 10.0, 'deceleration': 10.0, 'roll_speed': 480.0})
def _decode_unknown_struct49_0x294bbca0(data: typing.BinaryIO, property_size: int):
return UnknownStruct49.from_stream(data, property_size, default_override={'speed': 12.0, 'acceleration': 10.0, 'deceleration': 10.0, 'roll_speed': 180.0})
def _decode_flee_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct49_0x11c70370(data: typing.BinaryIO, property_size: int):
return UnknownStruct49.from_stream(data, property_size, default_override={'speed': 20.0, 'deceleration': 20.0, 'roll_speed': 180.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc8844cea: ('unknown_0xc8844cea', _decode_unknown_0xc8844cea),
0x9f8a1ca9: ('unknown_0x9f8a1ca9', _decode_unknown_0x9f8a1ca9),
0x72fc2ebd: ('unknown_0x72fc2ebd', _decode_unknown_0x72fc2ebd),
0xd2e52e7d: ('tired_duration', _decode_tired_duration),
0x66b5bc1e: ('unknown_0x66b5bc1e', _decode_unknown_0x66b5bc1e),
0xe021ceb0: ('unknown_0xe021ceb0', _decode_unknown_0xe021ceb0),
0x2b7d1d15: ('unknown_0x2b7d1d15', _decode_unknown_0x2b7d1d15),
0xc4a217ad: ('unknown_0xc4a217ad', _decode_unknown_0xc4a217ad),
0x84df6106: ('unknown_struct49_0x84df6106', _decode_unknown_struct49_0x84df6106),
0x9f91359a: ('unknown_struct49_0x9f91359a', _decode_unknown_struct49_0x9f91359a),
0x294bbca0: ('unknown_struct49_0x294bbca0', _decode_unknown_struct49_0x294bbca0),
0x501cc39f: ('flee_duration', _decode_flee_duration),
0x11c70370: ('unknown_struct49_0x11c70370', _decode_unknown_struct49_0x11c70370),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ForestBossStructB.py | 0.563618 | 0.266894 | ForestBossStructB.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 UnknownStruct27(BaseProperty):
appear: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
in_place: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
disappear: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
off_screen: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
up: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
down: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
left: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
right: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
cancel: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
select: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD', 'STRG']}, default=default_asset_id)
error: 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\x0b') # 11 properties
data.write(b'\xb2\xf9&t') # 0xb2f92674
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.appear))
data.write(b'\x12\xaa8\xc2') # 0x12aa38c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.in_place))
data.write(b'\x0c\xfe\x9a\xd0') # 0xcfe9ad0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.disappear))
data.write(b'\xe2?\xe8\xa7') # 0xe23fe8a7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.off_screen))
data.write(b'\xdc\xd1F\x11') # 0xdcd14611
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.up))
data.write(b'L\xff&\x83') # 0x4cff2683
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.down))
data.write(b'\x05\x03.\xd4') # 0x5032ed4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left))
data.write(b'g\x1d\xbf\xb5') # 0x671dbfb5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right))
data.write(b'M\x07\xa2\xff') # 0x4d07a2ff
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cancel))
data.write(b'\x8e\xd6R\x83') # 0x8ed65283
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select))
data.write(b'\xab_\x1bT') # 0xab5f1b54
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.error))
@classmethod
def from_json(cls, data: dict):
return cls(
appear=data['appear'],
in_place=data['in_place'],
disappear=data['disappear'],
off_screen=data['off_screen'],
up=data['up'],
down=data['down'],
left=data['left'],
right=data['right'],
cancel=data['cancel'],
select=data['select'],
error=data['error'],
)
def to_json(self) -> dict:
return {
'appear': self.appear,
'in_place': self.in_place,
'disappear': self.disappear,
'off_screen': self.off_screen,
'up': self.up,
'down': self.down,
'left': self.left,
'right': self.right,
'cancel': self.cancel,
'select': self.select,
'error': self.error,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb2f92674, 0x12aa38c2, 0xcfe9ad0, 0xe23fe8a7, 0xdcd14611, 0x4cff2683, 0x5032ed4, 0x671dbfb5, 0x4d07a2ff, 0x8ed65283, 0xab5f1b54)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct27]:
if property_count != 11:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQLHQLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(154))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct27(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
)
def _decode_appear(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_in_place(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_disappear(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_off_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_up(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_down(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cancel(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_error(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]]] = {
0xb2f92674: ('appear', _decode_appear),
0x12aa38c2: ('in_place', _decode_in_place),
0xcfe9ad0: ('disappear', _decode_disappear),
0xe23fe8a7: ('off_screen', _decode_off_screen),
0xdcd14611: ('up', _decode_up),
0x4cff2683: ('down', _decode_down),
0x5032ed4: ('left', _decode_left),
0x671dbfb5: ('right', _decode_right),
0x4d07a2ff: ('cancel', _decode_cancel),
0x8ed65283: ('select', _decode_select),
0xab5f1b54: ('error', _decode_error),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct27.py | 0.589126 | 0.215702 | UnknownStruct27.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 PlayerHeadTrackingData(BaseProperty):
animation: int = dataclasses.field(default=0)
unknown_0x7f96d93c: int = dataclasses.field(default=0)
unknown_0xd0ed78b3: int = dataclasses.field(default=0)
head_aim_locator: str = dataclasses.field(default='')
head_locator: str = dataclasses.field(default='')
upper_lip_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\x06') # 6 properties
data.write(b'\xaa\xcd\xb1\x1c') # 0xaacdb11c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation))
data.write(b'\x7f\x96\xd9<') # 0x7f96d93c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7f96d93c))
data.write(b'\xd0\xedx\xb3') # 0xd0ed78b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd0ed78b3))
data.write(b'\xf0\xebw-') # 0xf0eb772d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.head_aim_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'\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'\xa5\xfa\x9d"') # 0xa5fa9d22
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.upper_lip_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(
animation=data['animation'],
unknown_0x7f96d93c=data['unknown_0x7f96d93c'],
unknown_0xd0ed78b3=data['unknown_0xd0ed78b3'],
head_aim_locator=data['head_aim_locator'],
head_locator=data['head_locator'],
upper_lip_locator=data['upper_lip_locator'],
)
def to_json(self) -> dict:
return {
'animation': self.animation,
'unknown_0x7f96d93c': self.unknown_0x7f96d93c,
'unknown_0xd0ed78b3': self.unknown_0xd0ed78b3,
'head_aim_locator': self.head_aim_locator,
'head_locator': self.head_locator,
'upper_lip_locator': self.upper_lip_locator,
}
def _decode_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7f96d93c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd0ed78b3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_head_aim_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
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_upper_lip_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]]] = {
0xaacdb11c: ('animation', _decode_animation),
0x7f96d93c: ('unknown_0x7f96d93c', _decode_unknown_0x7f96d93c),
0xd0ed78b3: ('unknown_0xd0ed78b3', _decode_unknown_0xd0ed78b3),
0xf0eb772d: ('head_aim_locator', _decode_head_aim_locator),
0xda075c18: ('head_locator', _decode_head_locator),
0xa5fa9d22: ('upper_lip_locator', _decode_upper_lip_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerHeadTrackingData.py | 0.551332 | 0.251705 | PlayerHeadTrackingData.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.UnknownStruct160 import UnknownStruct160
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct163 import UnknownStruct163
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 UnknownStruct164(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
title_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
continue_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
core_continue_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
quit_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
quit_confirm_text: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown: UnknownStruct160 = dataclasses.field(default_factory=UnknownStruct160)
unknown_struct163: UnknownStruct163 = dataclasses.field(default_factory=UnknownStruct163)
unknown_struct26_0x860139ad: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
unknown_struct26_0x6a598a9b: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 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'\xef\xc5\xa17') # 0xefc5a137
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title_text))
data.write(b"\x1f['\x1d") # 0x1f5b271d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.continue_text))
data.write(b'D\x9fRu') # 0x449f5275
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.core_continue_text))
data.write(b'pI\xeeM') # 0x7049ee4d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.quit_text))
data.write(b'\xa9\x01\x07\xc6') # 0xa90107c6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
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'*\x83\xfb\xbb') # 0x2a83fbbb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'xg:\xb6') # 0x78673ab6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct163.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\x019\xad') # 0x860139ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x860139ad.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'jY\x8a\x9b') # 0x6a598a9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26_0x6a598a9b.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(
gui_frame=data['gui_frame'],
title_text=data['title_text'],
continue_text=data['continue_text'],
core_continue_text=data['core_continue_text'],
quit_text=data['quit_text'],
strg=data['strg'],
quit_confirm_text=data['quit_confirm_text'],
unknown=UnknownStruct160.from_json(data['unknown']),
unknown_struct163=UnknownStruct163.from_json(data['unknown_struct163']),
unknown_struct26_0x860139ad=UnknownStruct26.from_json(data['unknown_struct26_0x860139ad']),
unknown_struct26_0x6a598a9b=UnknownStruct26.from_json(data['unknown_struct26_0x6a598a9b']),
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'title_text': self.title_text,
'continue_text': self.continue_text,
'core_continue_text': self.core_continue_text,
'quit_text': self.quit_text,
'strg': self.strg,
'quit_confirm_text': self.quit_confirm_text,
'unknown': self.unknown.to_json(),
'unknown_struct163': self.unknown_struct163.to_json(),
'unknown_struct26_0x860139ad': self.unknown_struct26_0x860139ad.to_json(),
'unknown_struct26_0x6a598a9b': self.unknown_struct26_0x6a598a9b.to_json(),
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_title_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_continue_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_core_continue_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_quit_text(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_quit_confirm_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return UnknownStruct160.from_stream(data, property_size)
def _decode_unknown_struct163(data: typing.BinaryIO, property_size: int):
return UnknownStruct163.from_stream(data, property_size)
def _decode_unknown_struct26_0x860139ad(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_unknown_struct26_0x6a598a9b(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0xefc5a137: ('title_text', _decode_title_text),
0x1f5b271d: ('continue_text', _decode_continue_text),
0x449f5275: ('core_continue_text', _decode_core_continue_text),
0x7049ee4d: ('quit_text', _decode_quit_text),
0xa90107c6: ('strg', _decode_strg),
0xfdb3aac2: ('quit_confirm_text', _decode_quit_confirm_text),
0x2a83fbbb: ('unknown', _decode_unknown),
0x78673ab6: ('unknown_struct163', _decode_unknown_struct163),
0x860139ad: ('unknown_struct26_0x860139ad', _decode_unknown_struct26_0x860139ad),
0x6a598a9b: ('unknown_struct26_0x6a598a9b', _decode_unknown_struct26_0x6a598a9b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct164.py | 0.542621 | 0.168994 | UnknownStruct164.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class TextProperties(BaseProperty):
text_render_mode: enums.UnknownEnum3 = dataclasses.field(default=enums.UnknownEnum3.Unknown1)
text_bounding_width: int = dataclasses.field(default=1)
text_bounding_height: int = dataclasses.field(default=1)
line_spacing: float = dataclasses.field(default=100.0)
line_extra_space: int = dataclasses.field(default=0)
character_extra_space: int = dataclasses.field(default=0)
foreground_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
geometry_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
gradient_start: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
gradient_end: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
default_font: AssetId = dataclasses.field(metadata={'asset_types': ['FONT']}, default=default_asset_id)
unknown_0x18dd95cd: int = dataclasses.field(default=0)
unknown_0x42091548: int = dataclasses.field(default=0)
wrap_text: bool = dataclasses.field(default=False)
draw_shadow: 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\x10') # 16 properties
data.write(b'\x9f\x1b\xd4m') # 0x9f1bd46d
data.write(b'\x00\x04') # size
self.text_render_mode.to_stream(data)
data.write(b'\xeeR\x1d\xc6') # 0xee521dc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_bounding_width))
data.write(b'\xf2\xd3j\xbb') # 0xf2d36abb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_bounding_height))
data.write(b'\x1a\x99b\x92') # 0x1a996292
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.line_spacing))
data.write(b'\x05\xef\xf9\x13') # 0x5eff913
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.line_extra_space))
data.write(b'E\x83\t\x01') # 0x45830901
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.character_extra_space))
data.write(b'?9\xe65') # 0x3f39e635
data.write(b'\x00\x10') # size
self.foreground_color.to_stream(data)
data.write(b'`\xd7\x85i') # 0x60d78569
data.write(b'\x00\x10') # size
self.outline_color.to_stream(data)
data.write(b'Y\x08\xef9') # 0x5908ef39
data.write(b'\x00\x10') # size
self.geometry_color.to_stream(data)
data.write(b'\xfb\xb7\xbeE') # 0xfbb7be45
data.write(b'\x00\x10') # size
self.gradient_start.to_stream(data)
data.write(b'\x0f\xbc\xe3\xfb') # 0xfbce3fb
data.write(b'\x00\x10') # size
self.gradient_end.to_stream(data)
data.write(b'\r\xb9\xf8\xb6') # 0xdb9f8b6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.default_font))
data.write(b'\x18\xdd\x95\xcd') # 0x18dd95cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x18dd95cd))
data.write(b'B\t\x15H') # 0x42091548
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x42091548))
data.write(b'3\x05s\xe9') # 0x330573e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wrap_text))
data.write(b'\xd8\xa2\xee\xf0') # 0xd8a2eef0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.draw_shadow))
@classmethod
def from_json(cls, data: dict):
return cls(
text_render_mode=enums.UnknownEnum3.from_json(data['text_render_mode']),
text_bounding_width=data['text_bounding_width'],
text_bounding_height=data['text_bounding_height'],
line_spacing=data['line_spacing'],
line_extra_space=data['line_extra_space'],
character_extra_space=data['character_extra_space'],
foreground_color=Color.from_json(data['foreground_color']),
outline_color=Color.from_json(data['outline_color']),
geometry_color=Color.from_json(data['geometry_color']),
gradient_start=Color.from_json(data['gradient_start']),
gradient_end=Color.from_json(data['gradient_end']),
default_font=data['default_font'],
unknown_0x18dd95cd=data['unknown_0x18dd95cd'],
unknown_0x42091548=data['unknown_0x42091548'],
wrap_text=data['wrap_text'],
draw_shadow=data['draw_shadow'],
)
def to_json(self) -> dict:
return {
'text_render_mode': self.text_render_mode.to_json(),
'text_bounding_width': self.text_bounding_width,
'text_bounding_height': self.text_bounding_height,
'line_spacing': self.line_spacing,
'line_extra_space': self.line_extra_space,
'character_extra_space': self.character_extra_space,
'foreground_color': self.foreground_color.to_json(),
'outline_color': self.outline_color.to_json(),
'geometry_color': self.geometry_color.to_json(),
'gradient_start': self.gradient_start.to_json(),
'gradient_end': self.gradient_end.to_json(),
'default_font': self.default_font,
'unknown_0x18dd95cd': self.unknown_0x18dd95cd,
'unknown_0x42091548': self.unknown_0x42091548,
'wrap_text': self.wrap_text,
'draw_shadow': self.draw_shadow,
}
def _decode_text_render_mode(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum3.from_stream(data)
def _decode_text_bounding_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_text_bounding_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_line_spacing(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_line_extra_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_character_extra_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_foreground_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_geometry_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_gradient_start(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_gradient_end(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_default_font(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x18dd95cd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x42091548(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_wrap_text(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_draw_shadow(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]]] = {
0x9f1bd46d: ('text_render_mode', _decode_text_render_mode),
0xee521dc6: ('text_bounding_width', _decode_text_bounding_width),
0xf2d36abb: ('text_bounding_height', _decode_text_bounding_height),
0x1a996292: ('line_spacing', _decode_line_spacing),
0x5eff913: ('line_extra_space', _decode_line_extra_space),
0x45830901: ('character_extra_space', _decode_character_extra_space),
0x3f39e635: ('foreground_color', _decode_foreground_color),
0x60d78569: ('outline_color', _decode_outline_color),
0x5908ef39: ('geometry_color', _decode_geometry_color),
0xfbb7be45: ('gradient_start', _decode_gradient_start),
0xfbce3fb: ('gradient_end', _decode_gradient_end),
0xdb9f8b6: ('default_font', _decode_default_font),
0x18dd95cd: ('unknown_0x18dd95cd', _decode_unknown_0x18dd95cd),
0x42091548: ('unknown_0x42091548', _decode_unknown_0x42091548),
0x330573e9: ('wrap_text', _decode_wrap_text),
0xd8a2eef0: ('draw_shadow', _decode_draw_shadow),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TextProperties.py | 0.598312 | 0.189334 | TextProperties.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.VisControl import VisControl
@dataclasses.dataclass()
class SeparateAndReformParts(BaseProperty):
offset: float = dataclasses.field(default=0.0)
randomness: float = dataclasses.field(default=1.0)
apex: float = dataclasses.field(default=3.0)
vis_control: VisControl = dataclasses.field(default_factory=VisControl)
@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'F-<M') # 0x462d3c4d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.offset))
data.write(b't\x8eC\xfb') # 0x748e43fb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.randomness))
data.write(b'M7(\xe3') # 0x4d3728e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.apex))
data.write(b'h\x14\x98\xdd') # 0x681498dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vis_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
offset=data['offset'],
randomness=data['randomness'],
apex=data['apex'],
vis_control=VisControl.from_json(data['vis_control']),
)
def to_json(self) -> dict:
return {
'offset': self.offset,
'randomness': self.randomness,
'apex': self.apex,
'vis_control': self.vis_control.to_json(),
}
def _decode_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_randomness(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_apex(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vis_control(data: typing.BinaryIO, property_size: int):
return VisControl.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x462d3c4d: ('offset', _decode_offset),
0x748e43fb: ('randomness', _decode_randomness),
0x4d3728e3: ('apex', _decode_apex),
0x681498dd: ('vis_control', _decode_vis_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SeparateAndReformParts.py | 0.657318 | 0.331214 | SeparateAndReformParts.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
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 TandemBeam(BaseProperty):
tandem_beam_type: enums.TandemBeamType = dataclasses.field(default=enums.TandemBeamType.Unknown1)
maximum_beam_time: float = dataclasses.field(default=10.0)
activation_spline: Spline = dataclasses.field(default_factory=Spline)
beam_width: float = dataclasses.field(default=0.25)
beam_default_length: float = dataclasses.field(default=5.0)
beam_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
beam_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
beam_telegraph_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
beam_telegraph_length: float = dataclasses.field(default=1.0)
beam_scroll_direction: enums.BeamScrollDirection = dataclasses.field(default=enums.BeamScrollDirection.Unknown1)
beam_scroll_speed: float = dataclasses.field(default=0.0)
beam_texture_uv_flip_speed: float = dataclasses.field(default=0.0625)
alternate_beam_texture_v_coordinate: bool = dataclasses.field(default=True)
number_of_beam_texture_u_slots: int = dataclasses.field(default=4)
beam_texture_u0: float = dataclasses.field(default=0.0)
beam_texture_u1: float = dataclasses.field(default=0.5)
beam_texture_u2: float = dataclasses.field(default=0.25)
beam_texture_u3: float = dataclasses.field(default=0.75)
@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\x13') # 19 properties
data.write(b'\xd0E\xa1\x94') # 0xd045a194
data.write(b'\x00\x04') # size
self.tandem_beam_type.to_stream(data)
data.write(b'\xb8\xd6-\xdf') # 0xb8d62ddf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_beam_time))
data.write(b'\x92p\x8c~') # 0x92708c7e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.activation_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9V\xf3y') # 0xb956f379
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_width))
data.write(b'g\xa0\x8f\x89') # 0x67a08f89
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_default_length))
data.write(b'\x0c\xd0\x1c\x0e') # 0xcd01c0e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.beam_sound))
data.write(b'\xc6\xf2)\xc6') # 0xc6f229c6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.beam_texture))
data.write(b'\x1b$\x8c3') # 0x1b248c33
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.beam_telegraph_texture))
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaaz\xe2\xed') # 0xaa7ae2ed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_telegraph_length))
data.write(b'\xa5\xa3\xefc') # 0xa5a3ef63
data.write(b'\x00\x04') # size
self.beam_scroll_direction.to_stream(data)
data.write(b'\xab\xf9\xf6\xfd') # 0xabf9f6fd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_scroll_speed))
data.write(b'\xdbd\xab\xe3') # 0xdb64abe3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_texture_uv_flip_speed))
data.write(b'\x82\x05D#') # 0x82054423
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.alternate_beam_texture_v_coordinate))
data.write(b'\xad\xd9\xa3\xb6') # 0xadd9a3b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_beam_texture_u_slots))
data.write(b'\xe4\x07#\xff') # 0xe40723ff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_texture_u0))
data.write(b'/[\xf0Z') # 0x2f5bf05a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_texture_u1))
data.write(b'\xa9\xcf\x82\xf4') # 0xa9cf82f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_texture_u2))
data.write(b'b\x93QQ') # 0x62935151
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_texture_u3))
@classmethod
def from_json(cls, data: dict):
return cls(
tandem_beam_type=enums.TandemBeamType.from_json(data['tandem_beam_type']),
maximum_beam_time=data['maximum_beam_time'],
activation_spline=Spline.from_json(data['activation_spline']),
beam_width=data['beam_width'],
beam_default_length=data['beam_default_length'],
beam_sound=data['beam_sound'],
beam_texture=data['beam_texture'],
beam_telegraph_texture=data['beam_telegraph_texture'],
damage=DamageInfo.from_json(data['damage']),
beam_telegraph_length=data['beam_telegraph_length'],
beam_scroll_direction=enums.BeamScrollDirection.from_json(data['beam_scroll_direction']),
beam_scroll_speed=data['beam_scroll_speed'],
beam_texture_uv_flip_speed=data['beam_texture_uv_flip_speed'],
alternate_beam_texture_v_coordinate=data['alternate_beam_texture_v_coordinate'],
number_of_beam_texture_u_slots=data['number_of_beam_texture_u_slots'],
beam_texture_u0=data['beam_texture_u0'],
beam_texture_u1=data['beam_texture_u1'],
beam_texture_u2=data['beam_texture_u2'],
beam_texture_u3=data['beam_texture_u3'],
)
def to_json(self) -> dict:
return {
'tandem_beam_type': self.tandem_beam_type.to_json(),
'maximum_beam_time': self.maximum_beam_time,
'activation_spline': self.activation_spline.to_json(),
'beam_width': self.beam_width,
'beam_default_length': self.beam_default_length,
'beam_sound': self.beam_sound,
'beam_texture': self.beam_texture,
'beam_telegraph_texture': self.beam_telegraph_texture,
'damage': self.damage.to_json(),
'beam_telegraph_length': self.beam_telegraph_length,
'beam_scroll_direction': self.beam_scroll_direction.to_json(),
'beam_scroll_speed': self.beam_scroll_speed,
'beam_texture_uv_flip_speed': self.beam_texture_uv_flip_speed,
'alternate_beam_texture_v_coordinate': self.alternate_beam_texture_v_coordinate,
'number_of_beam_texture_u_slots': self.number_of_beam_texture_u_slots,
'beam_texture_u0': self.beam_texture_u0,
'beam_texture_u1': self.beam_texture_u1,
'beam_texture_u2': self.beam_texture_u2,
'beam_texture_u3': self.beam_texture_u3,
}
def _decode_tandem_beam_type(data: typing.BinaryIO, property_size: int):
return enums.TandemBeamType.from_stream(data)
def _decode_maximum_beam_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_activation_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_beam_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_default_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_beam_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_beam_telegraph_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_beam_telegraph_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_scroll_direction(data: typing.BinaryIO, property_size: int):
return enums.BeamScrollDirection.from_stream(data)
def _decode_beam_scroll_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_texture_uv_flip_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alternate_beam_texture_v_coordinate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_number_of_beam_texture_u_slots(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_beam_texture_u0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_texture_u1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_texture_u2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_texture_u3(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]]] = {
0xd045a194: ('tandem_beam_type', _decode_tandem_beam_type),
0xb8d62ddf: ('maximum_beam_time', _decode_maximum_beam_time),
0x92708c7e: ('activation_spline', _decode_activation_spline),
0xb956f379: ('beam_width', _decode_beam_width),
0x67a08f89: ('beam_default_length', _decode_beam_default_length),
0xcd01c0e: ('beam_sound', _decode_beam_sound),
0xc6f229c6: ('beam_texture', _decode_beam_texture),
0x1b248c33: ('beam_telegraph_texture', _decode_beam_telegraph_texture),
0x337f9524: ('damage', _decode_damage),
0xaa7ae2ed: ('beam_telegraph_length', _decode_beam_telegraph_length),
0xa5a3ef63: ('beam_scroll_direction', _decode_beam_scroll_direction),
0xabf9f6fd: ('beam_scroll_speed', _decode_beam_scroll_speed),
0xdb64abe3: ('beam_texture_uv_flip_speed', _decode_beam_texture_uv_flip_speed),
0x82054423: ('alternate_beam_texture_v_coordinate', _decode_alternate_beam_texture_v_coordinate),
0xadd9a3b6: ('number_of_beam_texture_u_slots', _decode_number_of_beam_texture_u_slots),
0xe40723ff: ('beam_texture_u0', _decode_beam_texture_u0),
0x2f5bf05a: ('beam_texture_u1', _decode_beam_texture_u1),
0xa9cf82f4: ('beam_texture_u2', _decode_beam_texture_u2),
0x62935151: ('beam_texture_u3', _decode_beam_texture_u3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TandemBeam.py | 0.626238 | 0.273577 | TandemBeam.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.RevolutionControl import RevolutionControl
@dataclasses.dataclass()
class MapControls(BaseProperty):
unknown_0xb5f75bfb: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x2ced2b18: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x640f66c6: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xdfe791c6: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x55861a4b: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xebd3a5f8: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x385cbd2f: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x5f55ccca: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x81e8cf07: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x2ac6123a: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
@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'\xb5\xf7[\xfb') # 0xb5f75bfb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb5f75bfb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b',\xed+\x18') # 0x2ced2b18
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x2ced2b18.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\x0ff\xc6') # 0x640f66c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x640f66c6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\xe7\x91\xc6') # 0xdfe791c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xdfe791c6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'U\x86\x1aK') # 0x55861a4b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x55861a4b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xd3\xa5\xf8') # 0xebd3a5f8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xebd3a5f8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'8\\\xbd/') # 0x385cbd2f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x385cbd2f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'_U\xcc\xca') # 0x5f55ccca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x5f55ccca.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x81\xe8\xcf\x07') # 0x81e8cf07
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x81e8cf07.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*\xc6\x12:') # 0x2ac6123a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x2ac6123a.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_0xb5f75bfb=RevolutionControl.from_json(data['unknown_0xb5f75bfb']),
unknown_0x2ced2b18=RevolutionControl.from_json(data['unknown_0x2ced2b18']),
unknown_0x640f66c6=RevolutionControl.from_json(data['unknown_0x640f66c6']),
unknown_0xdfe791c6=RevolutionControl.from_json(data['unknown_0xdfe791c6']),
unknown_0x55861a4b=RevolutionControl.from_json(data['unknown_0x55861a4b']),
unknown_0xebd3a5f8=RevolutionControl.from_json(data['unknown_0xebd3a5f8']),
unknown_0x385cbd2f=RevolutionControl.from_json(data['unknown_0x385cbd2f']),
unknown_0x5f55ccca=RevolutionControl.from_json(data['unknown_0x5f55ccca']),
unknown_0x81e8cf07=RevolutionControl.from_json(data['unknown_0x81e8cf07']),
unknown_0x2ac6123a=RevolutionControl.from_json(data['unknown_0x2ac6123a']),
)
def to_json(self) -> dict:
return {
'unknown_0xb5f75bfb': self.unknown_0xb5f75bfb.to_json(),
'unknown_0x2ced2b18': self.unknown_0x2ced2b18.to_json(),
'unknown_0x640f66c6': self.unknown_0x640f66c6.to_json(),
'unknown_0xdfe791c6': self.unknown_0xdfe791c6.to_json(),
'unknown_0x55861a4b': self.unknown_0x55861a4b.to_json(),
'unknown_0xebd3a5f8': self.unknown_0xebd3a5f8.to_json(),
'unknown_0x385cbd2f': self.unknown_0x385cbd2f.to_json(),
'unknown_0x5f55ccca': self.unknown_0x5f55ccca.to_json(),
'unknown_0x81e8cf07': self.unknown_0x81e8cf07.to_json(),
'unknown_0x2ac6123a': self.unknown_0x2ac6123a.to_json(),
}
def _decode_unknown_0xb5f75bfb(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x2ced2b18(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x640f66c6(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xdfe791c6(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x55861a4b(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xebd3a5f8(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x385cbd2f(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x5f55ccca(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x81e8cf07(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x2ac6123a(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb5f75bfb: ('unknown_0xb5f75bfb', _decode_unknown_0xb5f75bfb),
0x2ced2b18: ('unknown_0x2ced2b18', _decode_unknown_0x2ced2b18),
0x640f66c6: ('unknown_0x640f66c6', _decode_unknown_0x640f66c6),
0xdfe791c6: ('unknown_0xdfe791c6', _decode_unknown_0xdfe791c6),
0x55861a4b: ('unknown_0x55861a4b', _decode_unknown_0x55861a4b),
0xebd3a5f8: ('unknown_0xebd3a5f8', _decode_unknown_0xebd3a5f8),
0x385cbd2f: ('unknown_0x385cbd2f', _decode_unknown_0x385cbd2f),
0x5f55ccca: ('unknown_0x5f55ccca', _decode_unknown_0x5f55ccca),
0x81e8cf07: ('unknown_0x81e8cf07', _decode_unknown_0x81e8cf07),
0x2ac6123a: ('unknown_0x2ac6123a', _decode_unknown_0x2ac6123a),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MapControls.py | 0.499268 | 0.333747 | MapControls.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerAttackBounceData import PlayerAttackBounceData
@dataclasses.dataclass()
class PlayerJumpHeights(BaseProperty):
minimum_jump_height: float = dataclasses.field(default=2.0)
maximum_jump_height: float = dataclasses.field(default=4.5)
attack_bounce_data: PlayerAttackBounceData = dataclasses.field(default_factory=PlayerAttackBounceData)
@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'yz\xa5Q') # 0x797aa551
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_jump_height))
data.write(b'8m\x9a\xd7') # 0x386d9ad7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_jump_height))
data.write(b'\x95\x83\xee\x9a') # 0x9583ee9a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_bounce_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
minimum_jump_height=data['minimum_jump_height'],
maximum_jump_height=data['maximum_jump_height'],
attack_bounce_data=PlayerAttackBounceData.from_json(data['attack_bounce_data']),
)
def to_json(self) -> dict:
return {
'minimum_jump_height': self.minimum_jump_height,
'maximum_jump_height': self.maximum_jump_height,
'attack_bounce_data': self.attack_bounce_data.to_json(),
}
def _decode_minimum_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_jump_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_bounce_data(data: typing.BinaryIO, property_size: int):
return PlayerAttackBounceData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x797aa551: ('minimum_jump_height', _decode_minimum_jump_height),
0x386d9ad7: ('maximum_jump_height', _decode_maximum_jump_height),
0x9583ee9a: ('attack_bounce_data', _decode_attack_bounce_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerJumpHeights.py | 0.717606 | 0.322833 | PlayerJumpHeights.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class IslandHudStruct(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title: 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)
category_names: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0x3dc0f2be: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0x6fdabad6: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\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'\xdb\xff\xfaf') # 0xdbfffa66
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.category_names))
data.write(b'\x0e\xec\xd4\x88') # 0xeecd488
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'7\xfd\x19\x13') # 0x37fd1913
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction))
data.write(b'\xa1O4\xca') # 0xa14f34ca
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction_core))
data.write(b'=\xc0\xf2\xbe') # 0x3dc0f2be
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x3dc0f2be))
data.write(b'o\xda\xba\xd6') # 0x6fdabad6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x6fdabad6))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title=data['title'],
back=data['back'],
back_core=data['back_core'],
category_names=data['category_names'],
strg=data['strg'],
instruction=data['instruction'],
instruction_core=data['instruction_core'],
unknown_0x3dc0f2be=data['unknown_0x3dc0f2be'],
unknown_0x6fdabad6=data['unknown_0x6fdabad6'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title': self.title,
'back': self.back,
'back_core': self.back_core,
'category_names': self.category_names,
'strg': self.strg,
'instruction': self.instruction,
'instruction_core': self.instruction_core,
'unknown_0x3dc0f2be': self.unknown_0x3dc0f2be,
'unknown_0x6fdabad6': self.unknown_0x6fdabad6,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_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_category_names(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_instruction(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x3dc0f2be(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x6fdabad6(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0xa4f20c17: ('title', _decode_title),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0xdbfffa66: ('category_names', _decode_category_names),
0xeecd488: ('strg', _decode_strg),
0x37fd1913: ('instruction', _decode_instruction),
0xa14f34ca: ('instruction_core', _decode_instruction_core),
0x3dc0f2be: ('unknown_0x3dc0f2be', _decode_unknown_0x3dc0f2be),
0x6fdabad6: ('unknown_0x6fdabad6', _decode_unknown_0x6fdabad6),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/IslandHudStruct.py | 0.583559 | 0.178615 | IslandHudStruct.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 PlayerTerrainAlignmentData(BaseProperty):
use_search_box: bool = dataclasses.field(default=False)
search_box_size: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
search_radius: float = dataclasses.field(default=1.0499999523162842)
search_up_offset: float = dataclasses.field(default=0.20000000298023224)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
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'(\xfd1\x83') # 0x28fd3183
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_search_box))
data.write(b'\xb3\x93\x16Q') # 0xb3931651
data.write(b'\x00\x0c') # size
self.search_box_size.to_stream(data)
data.write(b'\xed\x9b\xf5\xa3') # 0xed9bf5a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_radius))
data.write(b'y"\r\xd6') # 0x79220dd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_up_offset))
@classmethod
def from_json(cls, data: dict):
return cls(
use_search_box=data['use_search_box'],
search_box_size=Vector.from_json(data['search_box_size']),
search_radius=data['search_radius'],
search_up_offset=data['search_up_offset'],
)
def to_json(self) -> dict:
return {
'use_search_box': self.use_search_box,
'search_box_size': self.search_box_size.to_json(),
'search_radius': self.search_radius,
'search_up_offset': self.search_up_offset,
}
def _decode_use_search_box(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_search_box_size(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_search_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_search_up_offset(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]]] = {
0x28fd3183: ('use_search_box', _decode_use_search_box),
0xb3931651: ('search_box_size', _decode_search_box_size),
0xed9bf5a3: ('search_radius', _decode_search_radius),
0x79220dd6: ('search_up_offset', _decode_search_up_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerTerrainAlignmentData.py | 0.70028 | 0.358465 | PlayerTerrainAlignmentData.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 CameraNavigation(BaseProperty):
unknown: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'"\xbd\x90\r') # 0x22bd900d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', 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 = (0x22bd900d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraNavigation]:
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 CameraNavigation(
dec[2],
)
def _decode_unknown(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]]] = {
0x22bd900d: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraNavigation.py | 0.647018 | 0.301182 | CameraNavigation.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 CameraFieldOfView(BaseProperty):
fov_type: int = dataclasses.field(default=2839405128) # Choice
unknown_0x69acc94a: int = dataclasses.field(default=0)
fov_path_object: enums.FOVPathObject = dataclasses.field(default=enums.FOVPathObject.Unknown1)
desired_fov: float = dataclasses.field(default=60.0)
unknown_0x972c0e20: Spline = dataclasses.field(default_factory=Spline)
unknown_0x812cf888: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\x19\xea\x15\x1b') # 0x19ea151b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.fov_type))
data.write(b'i\xac\xc9J') # 0x69acc94a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x69acc94a))
data.write(b'\xd1\xe9\x18\x86') # 0xd1e91886
data.write(b'\x00\x04') # size
self.fov_path_object.to_stream(data)
data.write(b'\xca\xfe=\xa7') # 0xcafe3da7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.desired_fov))
data.write(b'\x97,\x0e ') # 0x972c0e20
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x972c0e20.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x81,\xf8\x88') # 0x812cf888
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x812cf888.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
fov_type=data['fov_type'],
unknown_0x69acc94a=data['unknown_0x69acc94a'],
fov_path_object=enums.FOVPathObject.from_json(data['fov_path_object']),
desired_fov=data['desired_fov'],
unknown_0x972c0e20=Spline.from_json(data['unknown_0x972c0e20']),
unknown_0x812cf888=Spline.from_json(data['unknown_0x812cf888']),
)
def to_json(self) -> dict:
return {
'fov_type': self.fov_type,
'unknown_0x69acc94a': self.unknown_0x69acc94a,
'fov_path_object': self.fov_path_object.to_json(),
'desired_fov': self.desired_fov,
'unknown_0x972c0e20': self.unknown_0x972c0e20.to_json(),
'unknown_0x812cf888': self.unknown_0x812cf888.to_json(),
}
def _decode_fov_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x69acc94a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fov_path_object(data: typing.BinaryIO, property_size: int):
return enums.FOVPathObject.from_stream(data)
def _decode_desired_fov(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x972c0e20(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x812cf888(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]]] = {
0x19ea151b: ('fov_type', _decode_fov_type),
0x69acc94a: ('unknown_0x69acc94a', _decode_unknown_0x69acc94a),
0xd1e91886: ('fov_path_object', _decode_fov_path_object),
0xcafe3da7: ('desired_fov', _decode_desired_fov),
0x972c0e20: ('unknown_0x972c0e20', _decode_unknown_0x972c0e20),
0x812cf888: ('unknown_0x812cf888', _decode_unknown_0x812cf888),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraFieldOfView.py | 0.602529 | 0.269239 | CameraFieldOfView.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.UnknownStruct144 import UnknownStruct144
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct145 import UnknownStruct145
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct146 import UnknownStruct146
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct29 import UnknownStruct29
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct30(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title: 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_0x916baa3c: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
horizontal_mode: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x52b89ddf: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
horizontal_selected: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_struct144: UnknownStruct144 = dataclasses.field(default_factory=UnknownStruct144)
unknown_struct145: UnknownStruct145 = dataclasses.field(default_factory=UnknownStruct145)
unknown_struct146: UnknownStruct146 = dataclasses.field(default_factory=UnknownStruct146)
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\x0c') # 12 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\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'\x91k\xaa<') # 0x916baa3c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x916baa3c))
data.write(b'\xd3\xc1&\xf7') # 0xd3c126f7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.horizontal_mode))
data.write(b'R\xb8\x9d\xdf') # 0x52b89ddf
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x52b89ddf))
data.write(b'\xd7\xe1b\xe3') # 0xd7e162e3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.horizontal_selected))
data.write(b'\xfe#\x01\x8f') # 0xfe23018f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct144.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7\xd3\xe6\xc2') # 0xf7d3e6c2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct145.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0c;\x97\xb8') # 0xc3b97b8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct146.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(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title=data['title'],
back=data['back'],
back_core=data['back_core'],
strg_0x916baa3c=data['strg_0x916baa3c'],
horizontal_mode=data['horizontal_mode'],
strg_0x52b89ddf=data['strg_0x52b89ddf'],
horizontal_selected=data['horizontal_selected'],
unknown_struct144=UnknownStruct144.from_json(data['unknown_struct144']),
unknown_struct145=UnknownStruct145.from_json(data['unknown_struct145']),
unknown_struct146=UnknownStruct146.from_json(data['unknown_struct146']),
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title': self.title,
'back': self.back,
'back_core': self.back_core,
'strg_0x916baa3c': self.strg_0x916baa3c,
'horizontal_mode': self.horizontal_mode,
'strg_0x52b89ddf': self.strg_0x52b89ddf,
'horizontal_selected': self.horizontal_selected,
'unknown_struct144': self.unknown_struct144.to_json(),
'unknown_struct145': self.unknown_struct145.to_json(),
'unknown_struct146': self.unknown_struct146.to_json(),
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_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_0x916baa3c(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_horizontal_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x52b89ddf(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_horizontal_selected(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct144(data: typing.BinaryIO, property_size: int):
return UnknownStruct144.from_stream(data, property_size)
def _decode_unknown_struct145(data: typing.BinaryIO, property_size: int):
return UnknownStruct145.from_stream(data, property_size)
def _decode_unknown_struct146(data: typing.BinaryIO, property_size: int):
return UnknownStruct146.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]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0xa4f20c17: ('title', _decode_title),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x916baa3c: ('strg_0x916baa3c', _decode_strg_0x916baa3c),
0xd3c126f7: ('horizontal_mode', _decode_horizontal_mode),
0x52b89ddf: ('strg_0x52b89ddf', _decode_strg_0x52b89ddf),
0xd7e162e3: ('horizontal_selected', _decode_horizontal_selected),
0xfe23018f: ('unknown_struct144', _decode_unknown_struct144),
0xf7d3e6c2: ('unknown_struct145', _decode_unknown_struct145),
0xc3b97b8: ('unknown_struct146', _decode_unknown_struct146),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct30.py | 0.547222 | 0.177668 | UnknownStruct30.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 UnknownStruct245(BaseProperty):
can_crush_player: bool = dataclasses.field(default=False)
unknown_0x5409b2be: bool = dataclasses.field(default=False)
unknown_0xd8a25f18: bool = dataclasses.field(default=False)
enable_pinch: bool = dataclasses.field(default=True)
enable_crush: bool = dataclasses.field(default=True)
instant_kill: bool = dataclasses.field(default=False)
unknown_0xc75386a1: bool = dataclasses.field(default=False)
unknown_0x1e456737: bool = dataclasses.field(default=True)
unknown_0x5a60111f: bool = dataclasses.field(default=True)
unknown_0xcf2f0bf9: bool = dataclasses.field(default=True)
unknown_0x5783e404: bool = dataclasses.field(default=True)
can_crush_push_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\x0c') # 12 properties
data.write(b'"\xec\xf2>') # 0x22ecf23e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_crush_player))
data.write(b'T\t\xb2\xbe') # 0x5409b2be
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5409b2be))
data.write(b'\xd8\xa2_\x18') # 0xd8a25f18
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd8a25f18))
data.write(b'\xd9\x82\xbch') # 0xd982bc68
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_pinch))
data.write(b'\x0b\x11%\x0e') # 0xb11250e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_crush))
data.write(b'=Bd\xee') # 0x3d4264ee
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.instant_kill))
data.write(b'\xc7S\x86\xa1') # 0xc75386a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc75386a1))
data.write(b'\x1eEg7') # 0x1e456737
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x1e456737))
data.write(b'Z`\x11\x1f') # 0x5a60111f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5a60111f))
data.write(b'\xcf/\x0b\xf9') # 0xcf2f0bf9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcf2f0bf9))
data.write(b'W\x83\xe4\x04') # 0x5783e404
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5783e404))
data.write(b'W\x01\x8c\xf1') # 0x57018cf1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_crush_push_player))
@classmethod
def from_json(cls, data: dict):
return cls(
can_crush_player=data['can_crush_player'],
unknown_0x5409b2be=data['unknown_0x5409b2be'],
unknown_0xd8a25f18=data['unknown_0xd8a25f18'],
enable_pinch=data['enable_pinch'],
enable_crush=data['enable_crush'],
instant_kill=data['instant_kill'],
unknown_0xc75386a1=data['unknown_0xc75386a1'],
unknown_0x1e456737=data['unknown_0x1e456737'],
unknown_0x5a60111f=data['unknown_0x5a60111f'],
unknown_0xcf2f0bf9=data['unknown_0xcf2f0bf9'],
unknown_0x5783e404=data['unknown_0x5783e404'],
can_crush_push_player=data['can_crush_push_player'],
)
def to_json(self) -> dict:
return {
'can_crush_player': self.can_crush_player,
'unknown_0x5409b2be': self.unknown_0x5409b2be,
'unknown_0xd8a25f18': self.unknown_0xd8a25f18,
'enable_pinch': self.enable_pinch,
'enable_crush': self.enable_crush,
'instant_kill': self.instant_kill,
'unknown_0xc75386a1': self.unknown_0xc75386a1,
'unknown_0x1e456737': self.unknown_0x1e456737,
'unknown_0x5a60111f': self.unknown_0x5a60111f,
'unknown_0xcf2f0bf9': self.unknown_0xcf2f0bf9,
'unknown_0x5783e404': self.unknown_0x5783e404,
'can_crush_push_player': self.can_crush_push_player,
}
_FAST_FORMAT = None
_FAST_IDS = (0x22ecf23e, 0x5409b2be, 0xd8a25f18, 0xd982bc68, 0xb11250e, 0x3d4264ee, 0xc75386a1, 0x1e456737, 0x5a60111f, 0xcf2f0bf9, 0x5783e404, 0x57018cf1)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct245]:
if property_count != 12:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(84))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct245(
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_can_crush_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x5409b2be(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xd8a25f18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_pinch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_crush(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_instant_kill(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xc75386a1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x1e456737(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x5a60111f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xcf2f0bf9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x5783e404(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_crush_push_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]]] = {
0x22ecf23e: ('can_crush_player', _decode_can_crush_player),
0x5409b2be: ('unknown_0x5409b2be', _decode_unknown_0x5409b2be),
0xd8a25f18: ('unknown_0xd8a25f18', _decode_unknown_0xd8a25f18),
0xd982bc68: ('enable_pinch', _decode_enable_pinch),
0xb11250e: ('enable_crush', _decode_enable_crush),
0x3d4264ee: ('instant_kill', _decode_instant_kill),
0xc75386a1: ('unknown_0xc75386a1', _decode_unknown_0xc75386a1),
0x1e456737: ('unknown_0x1e456737', _decode_unknown_0x1e456737),
0x5a60111f: ('unknown_0x5a60111f', _decode_unknown_0x5a60111f),
0xcf2f0bf9: ('unknown_0xcf2f0bf9', _decode_unknown_0xcf2f0bf9),
0x5783e404: ('unknown_0x5783e404', _decode_unknown_0x5783e404),
0x57018cf1: ('can_crush_push_player', _decode_can_crush_push_player),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct245.py | 0.579519 | 0.276028 | UnknownStruct245.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.UnknownStruct76 import UnknownStruct76
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct77 import UnknownStruct77
@dataclasses.dataclass()
class CameraMotion(BaseProperty):
motion_type: int = dataclasses.field(default=888911163) # Choice
unknown_struct76: UnknownStruct76 = dataclasses.field(default_factory=UnknownStruct76)
unknown_struct77: UnknownStruct77 = dataclasses.field(default_factory=UnknownStruct77)
@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'\x94\x8a\xf5q') # 0x948af571
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.motion_type))
data.write(b'\xb4\nA\xb8') # 0xb40a41b8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct76.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0c8\xa0\t') # 0xc38a009
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct77.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(
motion_type=data['motion_type'],
unknown_struct76=UnknownStruct76.from_json(data['unknown_struct76']),
unknown_struct77=UnknownStruct77.from_json(data['unknown_struct77']),
)
def to_json(self) -> dict:
return {
'motion_type': self.motion_type,
'unknown_struct76': self.unknown_struct76.to_json(),
'unknown_struct77': self.unknown_struct77.to_json(),
}
def _decode_motion_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_struct76(data: typing.BinaryIO, property_size: int):
return UnknownStruct76.from_stream(data, property_size)
def _decode_unknown_struct77(data: typing.BinaryIO, property_size: int):
return UnknownStruct77.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x948af571: ('motion_type', _decode_motion_type),
0xb40a41b8: ('unknown_struct76', _decode_unknown_struct76),
0xc38a009: ('unknown_struct77', _decode_unknown_struct77),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraMotion.py | 0.605916 | 0.303203 | CameraMotion.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.TweakGraphicalTransitions.UnknownStruct2 import UnknownStruct2
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 UnknownStruct1(BaseProperty):
background: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
tiki_face: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
time_attack_stop_watch: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
black_screen: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
swirl: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
start_mask: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
end_mask: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
balloon_board: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
text_font_name: str = dataclasses.field(default='')
text_gradient_start_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
text_gradient_end_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
text_outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
text_decrement_time: float = dataclasses.field(default=1.0)
text_pos_x: float = dataclasses.field(default=0.0)
text_pos_y: float = dataclasses.field(default=0.0)
model_camera_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model_look_at_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
balloon_start_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
super_guide_dk_start_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
super_guide_anim_delay: float = dataclasses.field(default=0.0)
balloon_velocity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
quit_button_position: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
game_over_text_pos: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
button_text_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\x18') # 24 properties
data.write(b'x\xa6\x16G') # 0x78a61647
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.background.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d\xeaLd') # 0x8dea4c64
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tiki_face.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\xda\xfd\xc8') # 0xb9dafdc8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.time_attack_stop_watch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xc6\xc0<') # 0x64c6c03c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.black_screen.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'4yz ') # 0x34797a20
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swirl.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa6\x81\xd6U') # 0xa681d655
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.start_mask.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\x0c\x91\x1d') # 0x930c911d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.end_mask.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[vb\xce') # 0x5b7662ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balloon_board.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9k\xa9J') # 0xc96ba94a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.text_font_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'\xf9\xe0\xd0\xfb') # 0xf9e0d0fb
data.write(b'\x00\x10') # size
self.text_gradient_start_color.to_stream(data)
data.write(b'\xe0A~\x89') # 0xe0417e89
data.write(b'\x00\x10') # size
self.text_gradient_end_color.to_stream(data)
data.write(b'\xf2\xe15\x06') # 0xf2e13506
data.write(b'\x00\x10') # size
self.text_outline_color.to_stream(data)
data.write(b'\x9c\xd3]i') # 0x9cd35d69
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_decrement_time))
data.write(b'{Is\x13') # 0x7b497313
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_pos_x))
data.write(b'\xb0\x15\xa0\xb6') # 0xb015a0b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.text_pos_y))
data.write(b'\x0e\xd3\xbb\xa6') # 0xed3bba6
data.write(b'\x00\x0c') # size
self.model_camera_pos.to_stream(data)
data.write(b'h\xa2,_') # 0x68a22c5f
data.write(b'\x00\x0c') # size
self.model_look_at_pos.to_stream(data)
data.write(b'\xf9n\x96\xa8') # 0xf96e96a8
data.write(b'\x00\x0c') # size
self.balloon_start_pos.to_stream(data)
data.write(b'\xb65\xe8\xb7') # 0xb635e8b7
data.write(b'\x00\x0c') # size
self.super_guide_dk_start_pos.to_stream(data)
data.write(b'ji\xaa\x8c') # 0x6a69aa8c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.super_guide_anim_delay))
data.write(b'-\xd0\x91\x93') # 0x2dd09193
data.write(b'\x00\x0c') # size
self.balloon_velocity.to_stream(data)
data.write(b'\xbd]#\x95') # 0xbd5d2395
data.write(b'\x00\x0c') # size
self.quit_button_position.to_stream(data)
data.write(b'\x92\x1b\x9c\xdc') # 0x921b9cdc
data.write(b'\x00\x0c') # size
self.game_over_text_pos.to_stream(data)
data.write(b'\x92\xbe\x12\xe9') # 0x92be12e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.button_text_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(
background=UnknownStruct2.from_json(data['background']),
tiki_face=UnknownStruct2.from_json(data['tiki_face']),
time_attack_stop_watch=UnknownStruct2.from_json(data['time_attack_stop_watch']),
black_screen=UnknownStruct2.from_json(data['black_screen']),
swirl=UnknownStruct2.from_json(data['swirl']),
start_mask=UnknownStruct2.from_json(data['start_mask']),
end_mask=UnknownStruct2.from_json(data['end_mask']),
balloon_board=UnknownStruct2.from_json(data['balloon_board']),
text_font_name=data['text_font_name'],
text_gradient_start_color=Color.from_json(data['text_gradient_start_color']),
text_gradient_end_color=Color.from_json(data['text_gradient_end_color']),
text_outline_color=Color.from_json(data['text_outline_color']),
text_decrement_time=data['text_decrement_time'],
text_pos_x=data['text_pos_x'],
text_pos_y=data['text_pos_y'],
model_camera_pos=Vector.from_json(data['model_camera_pos']),
model_look_at_pos=Vector.from_json(data['model_look_at_pos']),
balloon_start_pos=Vector.from_json(data['balloon_start_pos']),
super_guide_dk_start_pos=Vector.from_json(data['super_guide_dk_start_pos']),
super_guide_anim_delay=data['super_guide_anim_delay'],
balloon_velocity=Vector.from_json(data['balloon_velocity']),
quit_button_position=Vector.from_json(data['quit_button_position']),
game_over_text_pos=Vector.from_json(data['game_over_text_pos']),
button_text_locator=data['button_text_locator'],
)
def to_json(self) -> dict:
return {
'background': self.background.to_json(),
'tiki_face': self.tiki_face.to_json(),
'time_attack_stop_watch': self.time_attack_stop_watch.to_json(),
'black_screen': self.black_screen.to_json(),
'swirl': self.swirl.to_json(),
'start_mask': self.start_mask.to_json(),
'end_mask': self.end_mask.to_json(),
'balloon_board': self.balloon_board.to_json(),
'text_font_name': self.text_font_name,
'text_gradient_start_color': self.text_gradient_start_color.to_json(),
'text_gradient_end_color': self.text_gradient_end_color.to_json(),
'text_outline_color': self.text_outline_color.to_json(),
'text_decrement_time': self.text_decrement_time,
'text_pos_x': self.text_pos_x,
'text_pos_y': self.text_pos_y,
'model_camera_pos': self.model_camera_pos.to_json(),
'model_look_at_pos': self.model_look_at_pos.to_json(),
'balloon_start_pos': self.balloon_start_pos.to_json(),
'super_guide_dk_start_pos': self.super_guide_dk_start_pos.to_json(),
'super_guide_anim_delay': self.super_guide_anim_delay,
'balloon_velocity': self.balloon_velocity.to_json(),
'quit_button_position': self.quit_button_position.to_json(),
'game_over_text_pos': self.game_over_text_pos.to_json(),
'button_text_locator': self.button_text_locator,
}
def _decode_background(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_tiki_face(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_time_attack_stop_watch(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_black_screen(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_swirl(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_start_mask(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_end_mask(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_balloon_board(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_text_font_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_text_gradient_start_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_gradient_end_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_text_decrement_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_text_pos_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_text_pos_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model_camera_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model_look_at_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_balloon_start_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_super_guide_dk_start_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_super_guide_anim_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_balloon_velocity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_quit_button_position(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_game_over_text_pos(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_button_text_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]]] = {
0x78a61647: ('background', _decode_background),
0x8dea4c64: ('tiki_face', _decode_tiki_face),
0xb9dafdc8: ('time_attack_stop_watch', _decode_time_attack_stop_watch),
0x64c6c03c: ('black_screen', _decode_black_screen),
0x34797a20: ('swirl', _decode_swirl),
0xa681d655: ('start_mask', _decode_start_mask),
0x930c911d: ('end_mask', _decode_end_mask),
0x5b7662ce: ('balloon_board', _decode_balloon_board),
0xc96ba94a: ('text_font_name', _decode_text_font_name),
0xf9e0d0fb: ('text_gradient_start_color', _decode_text_gradient_start_color),
0xe0417e89: ('text_gradient_end_color', _decode_text_gradient_end_color),
0xf2e13506: ('text_outline_color', _decode_text_outline_color),
0x9cd35d69: ('text_decrement_time', _decode_text_decrement_time),
0x7b497313: ('text_pos_x', _decode_text_pos_x),
0xb015a0b6: ('text_pos_y', _decode_text_pos_y),
0xed3bba6: ('model_camera_pos', _decode_model_camera_pos),
0x68a22c5f: ('model_look_at_pos', _decode_model_look_at_pos),
0xf96e96a8: ('balloon_start_pos', _decode_balloon_start_pos),
0xb635e8b7: ('super_guide_dk_start_pos', _decode_super_guide_dk_start_pos),
0x6a69aa8c: ('super_guide_anim_delay', _decode_super_guide_anim_delay),
0x2dd09193: ('balloon_velocity', _decode_balloon_velocity),
0xbd5d2395: ('quit_button_position', _decode_quit_button_position),
0x921b9cdc: ('game_over_text_pos', _decode_game_over_text_pos),
0x92be12e9: ('button_text_locator', _decode_button_text_locator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TweakGraphicalTransitions/UnknownStruct1.py | 0.651798 | 0.31459 | UnknownStruct1.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.Color import Color
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct2(BaseProperty):
resource_name: str = dataclasses.field(default='')
alpha_mask_name: str = dataclasses.field(default='')
draw_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
rendering_type: enums.TweakGraphicalTransitions_UnknownEnum1 = dataclasses.field(default=enums.TweakGraphicalTransitions_UnknownEnum1.Unknown1)
rotations_per_second: float = dataclasses.field(default=0.0)
delay_time: float = dataclasses.field(default=0.0)
display_time: float = dataclasses.field(default=2.0)
texture_alpha: Spline = dataclasses.field(default_factory=Spline)
texture_scale: Spline = dataclasses.field(default_factory=Spline)
separate_alpha_texture_scale: bool = dataclasses.field(default=False)
alpha_rotations_per_second: float = dataclasses.field(default=0.0)
alpha_texture_scale: Spline = dataclasses.field(default_factory=Spline)
vertical_from_center: Spline = dataclasses.field(default_factory=Spline)
draw_before_models: bool = dataclasses.field(default=True)
stretch_across_screen: bool = dataclasses.field(default=False)
pause_timing_for_code: bool = dataclasses.field(default=False)
pause_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x11') # 17 properties
data.write(b'\xd2\x11\xba\xed') # 0xd211baed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.resource_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'\xe2|\x08\xd5') # 0xe27c08d5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.alpha_mask_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'\xe3\xa5\x17\x1e') # 0xe3a5171e
data.write(b'\x00\x10') # size
self.draw_color.to_stream(data)
data.write(b'\x0b\x91\x85y') # 0xb918579
data.write(b'\x00\x04') # size
self.rendering_type.to_stream(data)
data.write(b'\xbe\xfcM\xa4') # 0xbefc4da4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotations_per_second))
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'\x1a&\xc1\xcc') # 0x1a26c1cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.display_time))
data.write(b'"\xac\x059') # 0x22ac0539
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.texture_alpha.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xee\x83_e') # 0xee835f65
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.texture_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xee\xd6\xe4\xd2') # 0xeed6e4d2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.separate_alpha_texture_scale))
data.write(b'\x02\x15O\xb4') # 0x2154fb4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alpha_rotations_per_second))
data.write(b'\xe4\xce\x05\x82') # 0xe4ce0582
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.alpha_texture_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x04\x84\xa7\xea') # 0x484a7ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vertical_from_center.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\xc31\xb1') # 0x77c331b1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.draw_before_models))
data.write(b'F\x17s9') # 0x46177339
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stretch_across_screen))
data.write(b'\xb1\xe6G.') # 0xb1e6472e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.pause_timing_for_code))
data.write(b'k\x08\xf2\xf2') # 0x6b08f2f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause_time))
@classmethod
def from_json(cls, data: dict):
return cls(
resource_name=data['resource_name'],
alpha_mask_name=data['alpha_mask_name'],
draw_color=Color.from_json(data['draw_color']),
rendering_type=enums.TweakGraphicalTransitions_UnknownEnum1.from_json(data['rendering_type']),
rotations_per_second=data['rotations_per_second'],
delay_time=data['delay_time'],
display_time=data['display_time'],
texture_alpha=Spline.from_json(data['texture_alpha']),
texture_scale=Spline.from_json(data['texture_scale']),
separate_alpha_texture_scale=data['separate_alpha_texture_scale'],
alpha_rotations_per_second=data['alpha_rotations_per_second'],
alpha_texture_scale=Spline.from_json(data['alpha_texture_scale']),
vertical_from_center=Spline.from_json(data['vertical_from_center']),
draw_before_models=data['draw_before_models'],
stretch_across_screen=data['stretch_across_screen'],
pause_timing_for_code=data['pause_timing_for_code'],
pause_time=data['pause_time'],
)
def to_json(self) -> dict:
return {
'resource_name': self.resource_name,
'alpha_mask_name': self.alpha_mask_name,
'draw_color': self.draw_color.to_json(),
'rendering_type': self.rendering_type.to_json(),
'rotations_per_second': self.rotations_per_second,
'delay_time': self.delay_time,
'display_time': self.display_time,
'texture_alpha': self.texture_alpha.to_json(),
'texture_scale': self.texture_scale.to_json(),
'separate_alpha_texture_scale': self.separate_alpha_texture_scale,
'alpha_rotations_per_second': self.alpha_rotations_per_second,
'alpha_texture_scale': self.alpha_texture_scale.to_json(),
'vertical_from_center': self.vertical_from_center.to_json(),
'draw_before_models': self.draw_before_models,
'stretch_across_screen': self.stretch_across_screen,
'pause_timing_for_code': self.pause_timing_for_code,
'pause_time': self.pause_time,
}
def _decode_resource_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_alpha_mask_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_draw_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_rendering_type(data: typing.BinaryIO, property_size: int):
return enums.TweakGraphicalTransitions_UnknownEnum1.from_stream(data)
def _decode_rotations_per_second(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_display_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_texture_alpha(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_texture_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_separate_alpha_texture_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_alpha_rotations_per_second(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alpha_texture_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_vertical_from_center(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_draw_before_models(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_stretch_across_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_pause_timing_for_code(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_pause_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]]] = {
0xd211baed: ('resource_name', _decode_resource_name),
0xe27c08d5: ('alpha_mask_name', _decode_alpha_mask_name),
0xe3a5171e: ('draw_color', _decode_draw_color),
0xb918579: ('rendering_type', _decode_rendering_type),
0xbefc4da4: ('rotations_per_second', _decode_rotations_per_second),
0x8e16e012: ('delay_time', _decode_delay_time),
0x1a26c1cc: ('display_time', _decode_display_time),
0x22ac0539: ('texture_alpha', _decode_texture_alpha),
0xee835f65: ('texture_scale', _decode_texture_scale),
0xeed6e4d2: ('separate_alpha_texture_scale', _decode_separate_alpha_texture_scale),
0x2154fb4: ('alpha_rotations_per_second', _decode_alpha_rotations_per_second),
0xe4ce0582: ('alpha_texture_scale', _decode_alpha_texture_scale),
0x484a7ea: ('vertical_from_center', _decode_vertical_from_center),
0x77c331b1: ('draw_before_models', _decode_draw_before_models),
0x46177339: ('stretch_across_screen', _decode_stretch_across_screen),
0xb1e6472e: ('pause_timing_for_code', _decode_pause_timing_for_code),
0x6b08f2f2: ('pause_time', _decode_pause_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TweakGraphicalTransitions/UnknownStruct2.py | 0.563498 | 0.30995 | UnknownStruct2.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.MapControls import MapControls
from retro_data_structures.properties.dkc_returns.archetypes.MiscControls import MiscControls
from retro_data_structures.properties.dkc_returns.archetypes.TweakControls.UnknownStruct2 import UnknownStruct2
from retro_data_structures.properties.dkc_returns.archetypes.TweakControls.UnknownStruct3 import UnknownStruct3
@dataclasses.dataclass()
class UnknownStruct1(BaseProperty):
unknown: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
map: MapControls = dataclasses.field(default_factory=MapControls)
misc: MiscControls = dataclasses.field(default_factory=MiscControls)
debug: UnknownStruct3 = dataclasses.field(default_factory=UnknownStruct3)
@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'K\xd8\xec\xb9') # 0x4bd8ecb9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9a\xcbJ\xce') # 0x9acb4ace
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.map.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbew\xde\xd2') # 0xbe77ded2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.misc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'G\x06\x99\x11') # 0x47069911
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.debug.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=UnknownStruct2.from_json(data['unknown']),
map=MapControls.from_json(data['map']),
misc=MiscControls.from_json(data['misc']),
debug=UnknownStruct3.from_json(data['debug']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown.to_json(),
'map': self.map.to_json(),
'misc': self.misc.to_json(),
'debug': self.debug.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_map(data: typing.BinaryIO, property_size: int):
return MapControls.from_stream(data, property_size)
def _decode_misc(data: typing.BinaryIO, property_size: int):
return MiscControls.from_stream(data, property_size)
def _decode_debug(data: typing.BinaryIO, property_size: int):
return UnknownStruct3.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4bd8ecb9: ('unknown', _decode_unknown),
0x9acb4ace: ('map', _decode_map),
0xbe77ded2: ('misc', _decode_misc),
0x47069911: ('debug', _decode_debug),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TweakControls/UnknownStruct1.py | 0.594198 | 0.268357 | UnknownStruct1.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.RevolutionControl import RevolutionControl
@dataclasses.dataclass()
class UnknownStruct2(BaseProperty):
unknown_0x1d9b5cc1: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x56aaa727: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xdccb2caa: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x3c573a20: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
jump: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xc66160e6: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xc6bc4b19: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x79810b2b: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xd6787ebe: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x532087d5: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x3ed13a6a: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x7aa0b07c: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x1c204629: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x1996475f: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0e') # 14 properties
data.write(b'\x1d\x9b\\\xc1') # 0x1d9b5cc1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1d9b5cc1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"V\xaa\xa7'") # 0x56aaa727
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x56aaa727.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdc\xcb,\xaa') # 0xdccb2caa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xdccb2caa.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<W: ') # 0x3c573a20
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x3c573a20.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'ko\xcec') # 0x6b6fce63
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6a`\xe6') # 0xc66160e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xc66160e6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbcK\x19') # 0xc6bc4b19
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xc6bc4b19.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'y\x81\x0b+') # 0x79810b2b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x79810b2b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd6x~\xbe') # 0xd6787ebe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xd6787ebe.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S \x87\xd5') # 0x532087d5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x532087d5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'>\xd1:j') # 0x3ed13a6a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x3ed13a6a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'z\xa0\xb0|') # 0x7aa0b07c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7aa0b07c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c F)') # 0x1c204629
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1c204629.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\x96G_') # 0x1996475f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1996475f.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_0x1d9b5cc1=RevolutionControl.from_json(data['unknown_0x1d9b5cc1']),
unknown_0x56aaa727=RevolutionControl.from_json(data['unknown_0x56aaa727']),
unknown_0xdccb2caa=RevolutionControl.from_json(data['unknown_0xdccb2caa']),
unknown_0x3c573a20=RevolutionControl.from_json(data['unknown_0x3c573a20']),
jump=RevolutionControl.from_json(data['jump']),
unknown_0xc66160e6=RevolutionControl.from_json(data['unknown_0xc66160e6']),
unknown_0xc6bc4b19=RevolutionControl.from_json(data['unknown_0xc6bc4b19']),
unknown_0x79810b2b=RevolutionControl.from_json(data['unknown_0x79810b2b']),
unknown_0xd6787ebe=RevolutionControl.from_json(data['unknown_0xd6787ebe']),
unknown_0x532087d5=RevolutionControl.from_json(data['unknown_0x532087d5']),
unknown_0x3ed13a6a=RevolutionControl.from_json(data['unknown_0x3ed13a6a']),
unknown_0x7aa0b07c=RevolutionControl.from_json(data['unknown_0x7aa0b07c']),
unknown_0x1c204629=RevolutionControl.from_json(data['unknown_0x1c204629']),
unknown_0x1996475f=RevolutionControl.from_json(data['unknown_0x1996475f']),
)
def to_json(self) -> dict:
return {
'unknown_0x1d9b5cc1': self.unknown_0x1d9b5cc1.to_json(),
'unknown_0x56aaa727': self.unknown_0x56aaa727.to_json(),
'unknown_0xdccb2caa': self.unknown_0xdccb2caa.to_json(),
'unknown_0x3c573a20': self.unknown_0x3c573a20.to_json(),
'jump': self.jump.to_json(),
'unknown_0xc66160e6': self.unknown_0xc66160e6.to_json(),
'unknown_0xc6bc4b19': self.unknown_0xc6bc4b19.to_json(),
'unknown_0x79810b2b': self.unknown_0x79810b2b.to_json(),
'unknown_0xd6787ebe': self.unknown_0xd6787ebe.to_json(),
'unknown_0x532087d5': self.unknown_0x532087d5.to_json(),
'unknown_0x3ed13a6a': self.unknown_0x3ed13a6a.to_json(),
'unknown_0x7aa0b07c': self.unknown_0x7aa0b07c.to_json(),
'unknown_0x1c204629': self.unknown_0x1c204629.to_json(),
'unknown_0x1996475f': self.unknown_0x1996475f.to_json(),
}
def _decode_unknown_0x1d9b5cc1(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x56aaa727(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xdccb2caa(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x3c573a20(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_jump(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xc66160e6(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xc6bc4b19(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x79810b2b(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xd6787ebe(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x532087d5(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x3ed13a6a(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x7aa0b07c(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x1c204629(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x1996475f(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1d9b5cc1: ('unknown_0x1d9b5cc1', _decode_unknown_0x1d9b5cc1),
0x56aaa727: ('unknown_0x56aaa727', _decode_unknown_0x56aaa727),
0xdccb2caa: ('unknown_0xdccb2caa', _decode_unknown_0xdccb2caa),
0x3c573a20: ('unknown_0x3c573a20', _decode_unknown_0x3c573a20),
0x6b6fce63: ('jump', _decode_jump),
0xc66160e6: ('unknown_0xc66160e6', _decode_unknown_0xc66160e6),
0xc6bc4b19: ('unknown_0xc6bc4b19', _decode_unknown_0xc6bc4b19),
0x79810b2b: ('unknown_0x79810b2b', _decode_unknown_0x79810b2b),
0xd6787ebe: ('unknown_0xd6787ebe', _decode_unknown_0xd6787ebe),
0x532087d5: ('unknown_0x532087d5', _decode_unknown_0x532087d5),
0x3ed13a6a: ('unknown_0x3ed13a6a', _decode_unknown_0x3ed13a6a),
0x7aa0b07c: ('unknown_0x7aa0b07c', _decode_unknown_0x7aa0b07c),
0x1c204629: ('unknown_0x1c204629', _decode_unknown_0x1c204629),
0x1996475f: ('unknown_0x1996475f', _decode_unknown_0x1996475f),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TweakControls/UnknownStruct2.py | 0.457137 | 0.2914 | UnknownStruct2.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.RevolutionControl.UnknownStruct2 import UnknownStruct2
from retro_data_structures.properties.dkc_returns.archetypes.RevolutionControl.UnknownStruct3 import UnknownStruct3
from retro_data_structures.properties.dkc_returns.archetypes.RevolutionControl.UnknownStruct4 import UnknownStruct4
@dataclasses.dataclass()
class UnknownStruct1(BaseProperty):
unknown_0xe1c76bfb: enums.RevolutionControl_UnknownEnum2 = dataclasses.field(default=enums.RevolutionControl_UnknownEnum2.Unknown1)
unknown_0x3d8010c2: UnknownStruct2 = dataclasses.field(default_factory=UnknownStruct2)
unknown_0x9e8e5bf9: UnknownStruct3 = dataclasses.field(default_factory=UnknownStruct3)
unknown_0x6d33ae8f: UnknownStruct4 = dataclasses.field(default_factory=UnknownStruct4)
@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'\xe1\xc7k\xfb') # 0xe1c76bfb
data.write(b'\x00\x04') # size
self.unknown_0xe1c76bfb.to_stream(data)
data.write(b'=\x80\x10\xc2') # 0x3d8010c2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x3d8010c2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9e\x8e[\xf9') # 0x9e8e5bf9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x9e8e5bf9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'm3\xae\x8f') # 0x6d33ae8f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x6d33ae8f.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_0xe1c76bfb=enums.RevolutionControl_UnknownEnum2.from_json(data['unknown_0xe1c76bfb']),
unknown_0x3d8010c2=UnknownStruct2.from_json(data['unknown_0x3d8010c2']),
unknown_0x9e8e5bf9=UnknownStruct3.from_json(data['unknown_0x9e8e5bf9']),
unknown_0x6d33ae8f=UnknownStruct4.from_json(data['unknown_0x6d33ae8f']),
)
def to_json(self) -> dict:
return {
'unknown_0xe1c76bfb': self.unknown_0xe1c76bfb.to_json(),
'unknown_0x3d8010c2': self.unknown_0x3d8010c2.to_json(),
'unknown_0x9e8e5bf9': self.unknown_0x9e8e5bf9.to_json(),
'unknown_0x6d33ae8f': self.unknown_0x6d33ae8f.to_json(),
}
def _decode_unknown_0xe1c76bfb(data: typing.BinaryIO, property_size: int):
return enums.RevolutionControl_UnknownEnum2.from_stream(data)
def _decode_unknown_0x3d8010c2(data: typing.BinaryIO, property_size: int):
return UnknownStruct2.from_stream(data, property_size)
def _decode_unknown_0x9e8e5bf9(data: typing.BinaryIO, property_size: int):
return UnknownStruct3.from_stream(data, property_size)
def _decode_unknown_0x6d33ae8f(data: typing.BinaryIO, property_size: int):
return UnknownStruct4.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xe1c76bfb: ('unknown_0xe1c76bfb', _decode_unknown_0xe1c76bfb),
0x3d8010c2: ('unknown_0x3d8010c2', _decode_unknown_0x3d8010c2),
0x9e8e5bf9: ('unknown_0x9e8e5bf9', _decode_unknown_0x9e8e5bf9),
0x6d33ae8f: ('unknown_0x6d33ae8f', _decode_unknown_0x6d33ae8f),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RevolutionControl/UnknownStruct1.py | 0.569972 | 0.257701 | UnknownStruct1.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 UnknownStruct3(BaseProperty):
center_x: float = dataclasses.field(default=320.0)
center_y: float = dataclasses.field(default=224.0)
width: float = dataclasses.field(default=32.0)
height: float = dataclasses.field(default=32.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'\x8c\x93\x8c?') # 0x8c938c3f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.center_x))
data.write(b'G\xcf_\x9a') # 0x47cf5f9a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.center_y))
data.write(b'\x10\xdbC\x81') # 0x10db4381
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.width))
data.write(b'\xc2\xbe\x03\r') # 0xc2be030d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.height))
@classmethod
def from_json(cls, data: dict):
return cls(
center_x=data['center_x'],
center_y=data['center_y'],
width=data['width'],
height=data['height'],
)
def to_json(self) -> dict:
return {
'center_x': self.center_x,
'center_y': self.center_y,
'width': self.width,
'height': self.height,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8c938c3f, 0x47cf5f9a, 0x10db4381, 0xc2be030d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct3]:
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 UnknownStruct3(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_center_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_center_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8c938c3f: ('center_x', _decode_center_x),
0x47cf5f9a: ('center_y', _decode_center_y),
0x10db4381: ('width', _decode_width),
0xc2be030d: ('height', _decode_height),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RevolutionControl/UnknownStruct3.py | 0.650911 | 0.306093 | UnknownStruct3.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 UnknownStruct2(BaseProperty):
center_x: float = dataclasses.field(default=320.0)
center_y: float = dataclasses.field(default=224.0)
min_radius: float = dataclasses.field(default=0.0)
max_radius: float = dataclasses.field(default=64.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'\x8c\x93\x8c?') # 0x8c938c3f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.center_x))
data.write(b'G\xcf_\x9a') # 0x47cf5f9a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.center_y))
data.write(b"|\xbf'\xca") # 0x7cbf27ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_radius))
data.write(b'\xc5\x99\xbc\xbb') # 0xc599bcbb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_radius))
@classmethod
def from_json(cls, data: dict):
return cls(
center_x=data['center_x'],
center_y=data['center_y'],
min_radius=data['min_radius'],
max_radius=data['max_radius'],
)
def to_json(self) -> dict:
return {
'center_x': self.center_x,
'center_y': self.center_y,
'min_radius': self.min_radius,
'max_radius': self.max_radius,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8c938c3f, 0x47cf5f9a, 0x7cbf27ca, 0xc599bcbb)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct2]:
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 UnknownStruct2(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_center_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_center_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_radius(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]]] = {
0x8c938c3f: ('center_x', _decode_center_x),
0x47cf5f9a: ('center_y', _decode_center_y),
0x7cbf27ca: ('min_radius', _decode_min_radius),
0xc599bcbb: ('max_radius', _decode_max_radius),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RevolutionControl/UnknownStruct2.py | 0.666171 | 0.337995 | UnknownStruct2.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 UnknownStruct4(BaseProperty):
center_x: float = dataclasses.field(default=320.0)
center_y: float = dataclasses.field(default=224.0)
min_radius: float = dataclasses.field(default=0.0)
max_radius: float = dataclasses.field(default=64.0)
initial_angle: float = dataclasses.field(default=45.0)
arc_angle: float = dataclasses.field(default=90.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'\x8c\x93\x8c?') # 0x8c938c3f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.center_x))
data.write(b'G\xcf_\x9a') # 0x47cf5f9a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.center_y))
data.write(b"|\xbf'\xca") # 0x7cbf27ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_radius))
data.write(b'\xc5\x99\xbc\xbb') # 0xc599bcbb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_radius))
data.write(b'\x90\xac\x80A') # 0x90ac8041
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_angle))
data.write(b'\xb5\x88\x90\xfb') # 0xb58890fb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.arc_angle))
@classmethod
def from_json(cls, data: dict):
return cls(
center_x=data['center_x'],
center_y=data['center_y'],
min_radius=data['min_radius'],
max_radius=data['max_radius'],
initial_angle=data['initial_angle'],
arc_angle=data['arc_angle'],
)
def to_json(self) -> dict:
return {
'center_x': self.center_x,
'center_y': self.center_y,
'min_radius': self.min_radius,
'max_radius': self.max_radius,
'initial_angle': self.initial_angle,
'arc_angle': self.arc_angle,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8c938c3f, 0x47cf5f9a, 0x7cbf27ca, 0xc599bcbb, 0x90ac8041, 0xb58890fb)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct4]:
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 UnknownStruct4(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_center_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_center_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_arc_angle(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]]] = {
0x8c938c3f: ('center_x', _decode_center_x),
0x47cf5f9a: ('center_y', _decode_center_y),
0x7cbf27ca: ('min_radius', _decode_min_radius),
0xc599bcbb: ('max_radius', _decode_max_radius),
0x90ac8041: ('initial_angle', _decode_initial_angle),
0xb58890fb: ('arc_angle', _decode_arc_angle),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RevolutionControl/UnknownStruct4.py | 0.629661 | 0.348645 | UnknownStruct4.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.RevolutionControl.UnknownStruct1 import UnknownStruct1
from retro_data_structures.properties.dkc_returns.archetypes.RevolutionPhysicalControl import RevolutionPhysicalControl
@dataclasses.dataclass()
class RevolutionControl(BaseProperty):
revolution_control_type: enums.RevolutionControlType = dataclasses.field(default=enums.RevolutionControlType.Unknown2)
physical_control: RevolutionPhysicalControl = dataclasses.field(default_factory=RevolutionPhysicalControl)
unknown_0x6e14bc06: enums.PhysicalControlBoolean = dataclasses.field(default=enums.PhysicalControlBoolean.Unknown1)
unknown_0xf0bf68a4: RevolutionPhysicalControl = dataclasses.field(default_factory=RevolutionPhysicalControl)
revolution_virtual_control: enums.RevolutionVirtualControl = dataclasses.field(default=enums.RevolutionVirtualControl.Unknown1)
unknown_0xebaabf01: enums.PhysicalControlBoolean = dataclasses.field(default=enums.PhysicalControlBoolean.Unknown1)
unknown_0xeda6d736: enums.RevolutionVirtualControl = dataclasses.field(default=enums.RevolutionVirtualControl.Unknown1)
unknown_0xbf80d594: enums.RevolutionControl_UnknownEnum1 = dataclasses.field(default=enums.RevolutionControl_UnknownEnum1.Unknown1)
unknown_0x91b8c18a: UnknownStruct1 = dataclasses.field(default_factory=UnknownStruct1)
@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'\x81\xcc=>') # 0x81cc3d3e
data.write(b'\x00\x04') # size
self.revolution_control_type.to_stream(data)
data.write(b'\xe6F\xd3\xb7') # 0xe646d3b7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.physical_control.to_stream(data, default_override={'physical_control': enums.PhysicalControl.Unknown3})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'n\x14\xbc\x06') # 0x6e14bc06
data.write(b'\x00\x04') # size
self.unknown_0x6e14bc06.to_stream(data)
data.write(b'\xf0\xbfh\xa4') # 0xf0bf68a4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xf0bf68a4.to_stream(data, default_override={'physical_control': enums.PhysicalControl.Unknown3})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe\x81\x9d\xdb') # 0xfe819ddb
data.write(b'\x00\x04') # size
self.revolution_virtual_control.to_stream(data)
data.write(b'\xeb\xaa\xbf\x01') # 0xebaabf01
data.write(b'\x00\x04') # size
self.unknown_0xebaabf01.to_stream(data)
data.write(b'\xed\xa6\xd76') # 0xeda6d736
data.write(b'\x00\x04') # size
self.unknown_0xeda6d736.to_stream(data)
data.write(b'\xbf\x80\xd5\x94') # 0xbf80d594
data.write(b'\x00\x04') # size
self.unknown_0xbf80d594.to_stream(data)
data.write(b'\x91\xb8\xc1\x8a') # 0x91b8c18a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x91b8c18a.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(
revolution_control_type=enums.RevolutionControlType.from_json(data['revolution_control_type']),
physical_control=RevolutionPhysicalControl.from_json(data['physical_control']),
unknown_0x6e14bc06=enums.PhysicalControlBoolean.from_json(data['unknown_0x6e14bc06']),
unknown_0xf0bf68a4=RevolutionPhysicalControl.from_json(data['unknown_0xf0bf68a4']),
revolution_virtual_control=enums.RevolutionVirtualControl.from_json(data['revolution_virtual_control']),
unknown_0xebaabf01=enums.PhysicalControlBoolean.from_json(data['unknown_0xebaabf01']),
unknown_0xeda6d736=enums.RevolutionVirtualControl.from_json(data['unknown_0xeda6d736']),
unknown_0xbf80d594=enums.RevolutionControl_UnknownEnum1.from_json(data['unknown_0xbf80d594']),
unknown_0x91b8c18a=UnknownStruct1.from_json(data['unknown_0x91b8c18a']),
)
def to_json(self) -> dict:
return {
'revolution_control_type': self.revolution_control_type.to_json(),
'physical_control': self.physical_control.to_json(),
'unknown_0x6e14bc06': self.unknown_0x6e14bc06.to_json(),
'unknown_0xf0bf68a4': self.unknown_0xf0bf68a4.to_json(),
'revolution_virtual_control': self.revolution_virtual_control.to_json(),
'unknown_0xebaabf01': self.unknown_0xebaabf01.to_json(),
'unknown_0xeda6d736': self.unknown_0xeda6d736.to_json(),
'unknown_0xbf80d594': self.unknown_0xbf80d594.to_json(),
'unknown_0x91b8c18a': self.unknown_0x91b8c18a.to_json(),
}
def _decode_revolution_control_type(data: typing.BinaryIO, property_size: int):
return enums.RevolutionControlType.from_stream(data)
def _decode_physical_control(data: typing.BinaryIO, property_size: int):
return RevolutionPhysicalControl.from_stream(data, property_size, default_override={'physical_control': enums.PhysicalControl.Unknown3})
def _decode_unknown_0x6e14bc06(data: typing.BinaryIO, property_size: int):
return enums.PhysicalControlBoolean.from_stream(data)
def _decode_unknown_0xf0bf68a4(data: typing.BinaryIO, property_size: int):
return RevolutionPhysicalControl.from_stream(data, property_size, default_override={'physical_control': enums.PhysicalControl.Unknown3})
def _decode_revolution_virtual_control(data: typing.BinaryIO, property_size: int):
return enums.RevolutionVirtualControl.from_stream(data)
def _decode_unknown_0xebaabf01(data: typing.BinaryIO, property_size: int):
return enums.PhysicalControlBoolean.from_stream(data)
def _decode_unknown_0xeda6d736(data: typing.BinaryIO, property_size: int):
return enums.RevolutionVirtualControl.from_stream(data)
def _decode_unknown_0xbf80d594(data: typing.BinaryIO, property_size: int):
return enums.RevolutionControl_UnknownEnum1.from_stream(data)
def _decode_unknown_0x91b8c18a(data: typing.BinaryIO, property_size: int):
return UnknownStruct1.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x81cc3d3e: ('revolution_control_type', _decode_revolution_control_type),
0xe646d3b7: ('physical_control', _decode_physical_control),
0x6e14bc06: ('unknown_0x6e14bc06', _decode_unknown_0x6e14bc06),
0xf0bf68a4: ('unknown_0xf0bf68a4', _decode_unknown_0xf0bf68a4),
0xfe819ddb: ('revolution_virtual_control', _decode_revolution_virtual_control),
0xebaabf01: ('unknown_0xebaabf01', _decode_unknown_0xebaabf01),
0xeda6d736: ('unknown_0xeda6d736', _decode_unknown_0xeda6d736),
0xbf80d594: ('unknown_0xbf80d594', _decode_unknown_0xbf80d594),
0x91b8c18a: ('unknown_0x91b8c18a', _decode_unknown_0x91b8c18a),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RevolutionControl/__init__.py | 0.509032 | 0.222711 | __init__.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct24 import UnknownStruct24
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct248 import UnknownStruct248
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct249 import UnknownStruct249
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class PlayerRespawn(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
player_freeze: bool = dataclasses.field(default=True)
player_thaw_time: float = dataclasses.field(default=1.0)
camera_freeze: bool = dataclasses.field(default=True)
unknown_struct248: UnknownStruct248 = dataclasses.field(default_factory=UnknownStruct248)
unknown_struct249: UnknownStruct249 = dataclasses.field(default_factory=UnknownStruct249)
layer_list: UnknownStruct24 = dataclasses.field(default_factory=UnknownStruct24)
balloon_character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
multiplayer_balloon_anim: int = dataclasses.field(default=0)
dk_balloon_character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
diddy_balloon_character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
super_guide_dk_character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PRSP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'e\x00\x16\xed') # 0x650016ed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player_freeze))
data.write(b'3\x0e\xdcD') # 0x330edc44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_thaw_time))
data.write(b'\x1d=\xc68') # 0x1d3dc638
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.camera_freeze))
data.write(b'=\x97\xfe\xf6') # 0x3d97fef6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct248.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xccR\x8e\xd6') # 0xcc528ed6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct249.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Ak\xd9\xeb') # 0x416bd9eb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_list.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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'V?5\xc8') # 0x563f35c8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.multiplayer_balloon_anim))
data.write(b'2\xce\x89\x9f') # 0x32ce899f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dk_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'\x16,\x82|') # 0x162c827c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.diddy_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'\x89\x9f\x84s') # 0x899f8473
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.super_guide_dk_character.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
player_freeze=data['player_freeze'],
player_thaw_time=data['player_thaw_time'],
camera_freeze=data['camera_freeze'],
unknown_struct248=UnknownStruct248.from_json(data['unknown_struct248']),
unknown_struct249=UnknownStruct249.from_json(data['unknown_struct249']),
layer_list=UnknownStruct24.from_json(data['layer_list']),
balloon_character=AnimationParameters.from_json(data['balloon_character']),
multiplayer_balloon_anim=data['multiplayer_balloon_anim'],
dk_balloon_character=AnimationParameters.from_json(data['dk_balloon_character']),
diddy_balloon_character=AnimationParameters.from_json(data['diddy_balloon_character']),
super_guide_dk_character=AnimationParameters.from_json(data['super_guide_dk_character']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'player_freeze': self.player_freeze,
'player_thaw_time': self.player_thaw_time,
'camera_freeze': self.camera_freeze,
'unknown_struct248': self.unknown_struct248.to_json(),
'unknown_struct249': self.unknown_struct249.to_json(),
'layer_list': self.layer_list.to_json(),
'balloon_character': self.balloon_character.to_json(),
'multiplayer_balloon_anim': self.multiplayer_balloon_anim,
'dk_balloon_character': self.dk_balloon_character.to_json(),
'diddy_balloon_character': self.diddy_balloon_character.to_json(),
'super_guide_dk_character': self.super_guide_dk_character.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_player_freeze(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player_thaw_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_freeze(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct248(data: typing.BinaryIO, property_size: int):
return UnknownStruct248.from_stream(data, property_size)
def _decode_unknown_struct249(data: typing.BinaryIO, property_size: int):
return UnknownStruct249.from_stream(data, property_size)
def _decode_layer_list(data: typing.BinaryIO, property_size: int):
return UnknownStruct24.from_stream(data, property_size)
def _decode_balloon_character(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_multiplayer_balloon_anim(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dk_balloon_character(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_diddy_balloon_character(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_super_guide_dk_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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x650016ed: ('player_freeze', _decode_player_freeze),
0x330edc44: ('player_thaw_time', _decode_player_thaw_time),
0x1d3dc638: ('camera_freeze', _decode_camera_freeze),
0x3d97fef6: ('unknown_struct248', _decode_unknown_struct248),
0xcc528ed6: ('unknown_struct249', _decode_unknown_struct249),
0x416bd9eb: ('layer_list', _decode_layer_list),
0xf8b3abe0: ('balloon_character', _decode_balloon_character),
0x563f35c8: ('multiplayer_balloon_anim', _decode_multiplayer_balloon_anim),
0x32ce899f: ('dk_balloon_character', _decode_dk_balloon_character),
0x162c827c: ('diddy_balloon_character', _decode_diddy_balloon_character),
0x899f8473: ('super_guide_dk_character', _decode_super_guide_dk_character),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PlayerRespawn.py | 0.567817 | 0.303938 | PlayerRespawn.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct296 import UnknownStruct296
@dataclasses.dataclass()
class VolcanoBossBodyPart(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct296: UnknownStruct296 = dataclasses.field(default_factory=UnknownStruct296)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'VBPT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_VolcanoBoss.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x81\xc8>') # 0xbf81c83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x84Pic') # 0x84506963
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct296.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct296=UnknownStruct296.from_json(data['unknown_struct296']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct296': self.unknown_struct296.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_data(data: typing.BinaryIO, property_size: int):
return ShadowData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_unknown_struct296(data: typing.BinaryIO, property_size: int):
return UnknownStruct296.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x84506963: ('unknown_struct296', _decode_unknown_struct296),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/VolcanoBossBodyPart.py | 0.691393 | 0.318035 | VolcanoBossBodyPart.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Waypoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WAYP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Waypoint.py | 0.604049 | 0.357904 | Waypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ClingPathControlData import ClingPathControlData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class ClingPathControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
path_flags: int = dataclasses.field(default=0)
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
cling_path_control_data: ClingPathControlData = dataclasses.field(default_factory=ClingPathControlData)
editor_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CLPC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xb9\x7f\x9f') # 0xb0b97f9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.path_flags))
data.write(b' \t\x1bT') # 0x20091b54
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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'I\x85\xa0\x99') # 0x4985a099
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cling_path_control_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xdd\x86\xe2') # 0xdd86e2
data.write(b'\x00\x10') # size
self.editor_color.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
path_flags=data['path_flags'],
spline_type=SplineType.from_json(data['spline_type']),
cling_path_control_data=ClingPathControlData.from_json(data['cling_path_control_data']),
editor_color=Color.from_json(data['editor_color']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'path_flags': self.path_flags,
'spline_type': self.spline_type.to_json(),
'cling_path_control_data': self.cling_path_control_data.to_json(),
'editor_color': self.editor_color.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_path_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_cling_path_control_data(data: typing.BinaryIO, property_size: int):
return ClingPathControlData.from_stream(data, property_size)
def _decode_editor_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb0b97f9f: ('path_flags', _decode_path_flags),
0x20091b54: ('spline_type', _decode_spline_type),
0x4985a099: ('cling_path_control_data', _decode_cling_path_control_data),
0xdd86e2: ('editor_color', _decode_editor_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ClingPathControl.py | 0.6488 | 0.309695 | ClingPathControl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.TextProperties import TextProperties
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 TextPane(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_label: str = dataclasses.field(default='')
text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
japan_text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
pivot_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
default_string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
default_string_name: str = dataclasses.field(default='')
blend_mode: int = dataclasses.field(default=1)
fade_in_time: float = dataclasses.field(default=0.25)
fade_out_time: float = dataclasses.field(default=0.25)
depth_compare: bool = dataclasses.field(default=True)
depth_update: bool = dataclasses.field(default=True)
depth_backwards: bool = dataclasses.field(default=False)
use_animation: bool = dataclasses.field(default=False)
unknown: bool = dataclasses.field(default=False)
render_last: bool = dataclasses.field(default=False)
render_in_foreground: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TXPN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x11') # 17 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\x93\x94\x07') # 0x73939407
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.gui_label.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'\xe0T>f') # 0xe0543e66
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.text_properties.to_stream(data, default_override={'text_bounding_width': 80, 'text_bounding_height': 10})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8\xe4A\xfa') # 0xc8e441fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.japan_text_properties.to_stream(data, default_override={'text_bounding_width': 80, 'text_bounding_height': 10})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xde\xf2\x1b\xf5') # 0xdef21bf5
data.write(b'\x00\x0c') # size
self.pivot_offset.to_stream(data)
data.write(b"\xe7\xac9'") # 0xe7ac3927
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.default_string))
data.write(b'\xd5\x01\xc8~') # 0xd501c87e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.default_string_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'\x94\xf06\\') # 0x94f0365c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blend_mode))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\x94\xc0\x1b\x0c') # 0x94c01b0c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_compare))
data.write(b'\xae\xd2ZQ') # 0xaed25a51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_update))
data.write(b'5\xdcC\xd0') # 0x35dc43d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_backwards))
data.write(b'\xc6\xaa\xbe\x9a') # 0xc6aabe9a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_animation))
data.write(b'\xf5\x93{\x1f') # 0xf5937b1f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x95\xda\xde\x93') # 0x95dade93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_last))
data.write(b'\xa6\xaa\x06\xd5') # 0xa6aa06d5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_in_foreground))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
gui_label=data['gui_label'],
text_properties=TextProperties.from_json(data['text_properties']),
japan_text_properties=TextProperties.from_json(data['japan_text_properties']),
pivot_offset=Vector.from_json(data['pivot_offset']),
default_string=data['default_string'],
default_string_name=data['default_string_name'],
blend_mode=data['blend_mode'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
depth_compare=data['depth_compare'],
depth_update=data['depth_update'],
depth_backwards=data['depth_backwards'],
use_animation=data['use_animation'],
unknown=data['unknown'],
render_last=data['render_last'],
render_in_foreground=data['render_in_foreground'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_label': self.gui_label,
'text_properties': self.text_properties.to_json(),
'japan_text_properties': self.japan_text_properties.to_json(),
'pivot_offset': self.pivot_offset.to_json(),
'default_string': self.default_string,
'default_string_name': self.default_string_name,
'blend_mode': self.blend_mode,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'depth_compare': self.depth_compare,
'depth_update': self.depth_update,
'depth_backwards': self.depth_backwards,
'use_animation': self.use_animation,
'unknown': self.unknown,
'render_last': self.render_last,
'render_in_foreground': self.render_in_foreground,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_gui_label(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 80, 'text_bounding_height': 10})
def _decode_japan_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 80, 'text_bounding_height': 10})
def _decode_pivot_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_default_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_default_string_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_depth_compare(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_update(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_backwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_animation(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_render_last(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x73939407: ('gui_label', _decode_gui_label),
0xe0543e66: ('text_properties', _decode_text_properties),
0xc8e441fa: ('japan_text_properties', _decode_japan_text_properties),
0xdef21bf5: ('pivot_offset', _decode_pivot_offset),
0xe7ac3927: ('default_string', _decode_default_string),
0xd501c87e: ('default_string_name', _decode_default_string_name),
0x94f0365c: ('blend_mode', _decode_blend_mode),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0x94c01b0c: ('depth_compare', _decode_depth_compare),
0xaed25a51: ('depth_update', _decode_depth_update),
0x35dc43d0: ('depth_backwards', _decode_depth_backwards),
0xc6aabe9a: ('use_animation', _decode_use_animation),
0xf5937b1f: ('unknown', _decode_unknown),
0x95dade93: ('render_last', _decode_render_last),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TextPane.py | 0.562777 | 0.300181 | TextPane.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct93 import UnknownStruct93
@dataclasses.dataclass()
class DepthOfFieldTuner(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct93: UnknownStruct93 = dataclasses.field(default_factory=UnknownStruct93)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DOFT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'rv|\x80') # 0x72767c80
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct93.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct93=UnknownStruct93.from_json(data['unknown_struct93']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct93': self.unknown_struct93.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct93(data: typing.BinaryIO, property_size: int):
return UnknownStruct93.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x72767c80: ('unknown_struct93', _decode_unknown_struct93),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DepthOfFieldTuner.py | 0.623033 | 0.341431 | DepthOfFieldTuner.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct208 import UnknownStruct208
@dataclasses.dataclass()
class JungleBoss1(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct208: UnknownStruct208 = dataclasses.field(default_factory=UnknownStruct208)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'JB01'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_UglyBros.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x81\xc8>') # 0xbf81c83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16!!\x98') # 0x16212198
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct208.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct208=UnknownStruct208.from_json(data['unknown_struct208']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct208': self.unknown_struct208.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_data(data: typing.BinaryIO, property_size: int):
return ShadowData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_unknown_struct208(data: typing.BinaryIO, property_size: int):
return UnknownStruct208.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x16212198: ('unknown_struct208', _decode_unknown_struct208),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/JungleBoss1.py | 0.661376 | 0.322486 | JungleBoss1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class StreamedAudio(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
song_file: AssetId = dataclasses.field(metadata={'asset_types': ['STRM']}, default=default_asset_id)
dvd_file: str = dataclasses.field(default='')
auto_buffer: bool = dataclasses.field(default=False)
auto_buffer_when_stopped: bool = dataclasses.field(default=False)
auto_play_when_buffered: bool = dataclasses.field(default=False)
start_faded_out: bool = dataclasses.field(default=False)
fade_in_time: float = dataclasses.field(default=0.05000000074505806)
fade_out_time: float = dataclasses.field(default=0.25)
volume: float = dataclasses.field(default=-6.0)
pan: float = dataclasses.field(default=0.0)
positional: bool = dataclasses.field(default=False)
min_audible_distance: float = dataclasses.field(default=2.0)
max_audible_distance: float = dataclasses.field(default=75.0)
fall_off: float = dataclasses.field(default=0.0)
use_room_acoustics: bool = dataclasses.field(default=True)
start_sample: int = dataclasses.field(default=0)
is_default_retronome_music: bool = dataclasses.field(default=False)
part_of_music_system: bool = dataclasses.field(default=False)
save_preload_data: bool = dataclasses.field(default=False)
sound_group_names: str = dataclasses.field(default='')
start_delay: float = dataclasses.field(default=0.0)
music_system_area_state: enums.MusicEnumB = dataclasses.field(default=enums.MusicEnumB.Unknown1)
volume_type: enums.MusicEnumA = dataclasses.field(default=enums.MusicEnumA.Unknown2)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'STAU'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x18') # 24 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9d\x1ag\xa8') # 0x9d1a67a8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.song_file))
data.write(b'\xb4\x17\x06J') # 0xb417064a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.dvd_file.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'\xc0>\xc2q') # 0xc03ec271
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_buffer))
data.write(b'\x0ehu\x18') # 0xe687518
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_buffer_when_stopped))
data.write(b'\xea\x8dT\xf4') # 0xea8d54f4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_play_when_buffered))
data.write(b'\xeb%\n\x0b') # 0xeb250a0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_faded_out))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'\xdfCS\xa3') # 0xdf4353a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan))
data.write(b'n\x0e\x81\xf8') # 0x6e0e81f8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.positional))
data.write(b'%\xd4y\x8a') # 0x25d4798a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_audible_distance))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'rS\x18g') # 0x72531867
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fall_off))
data.write(b'\x85psT') # 0x85707354
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_room_acoustics))
data.write(b'\xe8\x8f\xf3w') # 0xe88ff377
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.start_sample))
data.write(b'\x07\x94\xc3\xeb') # 0x794c3eb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_default_retronome_music))
data.write(b'.|t_') # 0x2e7c745f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.part_of_music_system))
data.write(b'\xd7BE\xa4') # 0xd74245a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.save_preload_data))
data.write(b'\xc8q\xbd\x1b') # 0xc871bd1b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.sound_group_names.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'\x19n\x17\xd9') # 0x196e17d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_delay))
data.write(b'\xfb\x8f\x0b\x1f') # 0xfb8f0b1f
data.write(b'\x00\x04') # size
self.music_system_area_state.to_stream(data)
data.write(b'\x95Xq\x1e') # 0x9558711e
data.write(b'\x00\x04') # size
self.volume_type.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
song_file=data['song_file'],
dvd_file=data['dvd_file'],
auto_buffer=data['auto_buffer'],
auto_buffer_when_stopped=data['auto_buffer_when_stopped'],
auto_play_when_buffered=data['auto_play_when_buffered'],
start_faded_out=data['start_faded_out'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
volume=data['volume'],
pan=data['pan'],
positional=data['positional'],
min_audible_distance=data['min_audible_distance'],
max_audible_distance=data['max_audible_distance'],
fall_off=data['fall_off'],
use_room_acoustics=data['use_room_acoustics'],
start_sample=data['start_sample'],
is_default_retronome_music=data['is_default_retronome_music'],
part_of_music_system=data['part_of_music_system'],
save_preload_data=data['save_preload_data'],
sound_group_names=data['sound_group_names'],
start_delay=data['start_delay'],
music_system_area_state=enums.MusicEnumB.from_json(data['music_system_area_state']),
volume_type=enums.MusicEnumA.from_json(data['volume_type']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'song_file': self.song_file,
'dvd_file': self.dvd_file,
'auto_buffer': self.auto_buffer,
'auto_buffer_when_stopped': self.auto_buffer_when_stopped,
'auto_play_when_buffered': self.auto_play_when_buffered,
'start_faded_out': self.start_faded_out,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'volume': self.volume,
'pan': self.pan,
'positional': self.positional,
'min_audible_distance': self.min_audible_distance,
'max_audible_distance': self.max_audible_distance,
'fall_off': self.fall_off,
'use_room_acoustics': self.use_room_acoustics,
'start_sample': self.start_sample,
'is_default_retronome_music': self.is_default_retronome_music,
'part_of_music_system': self.part_of_music_system,
'save_preload_data': self.save_preload_data,
'sound_group_names': self.sound_group_names,
'start_delay': self.start_delay,
'music_system_area_state': self.music_system_area_state.to_json(),
'volume_type': self.volume_type.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_song_file(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_dvd_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_auto_buffer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_buffer_when_stopped(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_play_when_buffered(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_faded_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_positional(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_min_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fall_off(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_room_acoustics(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_sample(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_default_retronome_music(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_part_of_music_system(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_save_preload_data(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_group_names(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_start_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_music_system_area_state(data: typing.BinaryIO, property_size: int):
return enums.MusicEnumB.from_stream(data)
def _decode_volume_type(data: typing.BinaryIO, property_size: int):
return enums.MusicEnumA.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x9d1a67a8: ('song_file', _decode_song_file),
0xb417064a: ('dvd_file', _decode_dvd_file),
0xc03ec271: ('auto_buffer', _decode_auto_buffer),
0xe687518: ('auto_buffer_when_stopped', _decode_auto_buffer_when_stopped),
0xea8d54f4: ('auto_play_when_buffered', _decode_auto_play_when_buffered),
0xeb250a0b: ('start_faded_out', _decode_start_faded_out),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0xc7a7f189: ('volume', _decode_volume),
0xdf4353a3: ('pan', _decode_pan),
0x6e0e81f8: ('positional', _decode_positional),
0x25d4798a: ('min_audible_distance', _decode_min_audible_distance),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x72531867: ('fall_off', _decode_fall_off),
0x85707354: ('use_room_acoustics', _decode_use_room_acoustics),
0xe88ff377: ('start_sample', _decode_start_sample),
0x794c3eb: ('is_default_retronome_music', _decode_is_default_retronome_music),
0x2e7c745f: ('part_of_music_system', _decode_part_of_music_system),
0xd74245a4: ('save_preload_data', _decode_save_preload_data),
0xc871bd1b: ('sound_group_names', _decode_sound_group_names),
0x196e17d9: ('start_delay', _decode_start_delay),
0xfb8f0b1f: ('music_system_area_state', _decode_music_system_area_state),
0x9558711e: ('volume_type', _decode_volume_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/StreamedAudio.py | 0.558447 | 0.277779 | StreamedAudio.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Color import Color
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class SkyboxModInca(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SBMI'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\x92-\x15\x1f') # 0x922d151f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
color=Color.from_json(data['color']),
spline=Spline.from_json(data['spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'color': self.color.to_json(),
'spline': self.spline.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x37c7d09d: ('color', _decode_color),
0x922d151f: ('spline', _decode_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SkyboxModInca.py | 0.678433 | 0.341885 | SkyboxModInca.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TransitionScreen(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
transition_type: enums.TransitionType = dataclasses.field(default=enums.TransitionType.Unknown1)
unknown_0x5106feb9: bool = dataclasses.field(default=False)
unknown_0x49469271: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TRSC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5\xe8iX') # 0xf5e86958
data.write(b'\x00\x04') # size
self.transition_type.to_stream(data)
data.write(b'Q\x06\xfe\xb9') # 0x5106feb9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5106feb9))
data.write(b'IF\x92q') # 0x49469271
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x49469271))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
transition_type=enums.TransitionType.from_json(data['transition_type']),
unknown_0x5106feb9=data['unknown_0x5106feb9'],
unknown_0x49469271=data['unknown_0x49469271'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'transition_type': self.transition_type.to_json(),
'unknown_0x5106feb9': self.unknown_0x5106feb9,
'unknown_0x49469271': self.unknown_0x49469271,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_transition_type(data: typing.BinaryIO, property_size: int):
return enums.TransitionType.from_stream(data)
def _decode_unknown_0x5106feb9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x49469271(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf5e86958: ('transition_type', _decode_transition_type),
0x5106feb9: ('unknown_0x5106feb9', _decode_unknown_0x5106feb9),
0x49469271: ('unknown_0x49469271', _decode_unknown_0x49469271),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TransitionScreen.py | 0.629661 | 0.333313 | TransitionScreen.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class GuiMenu(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
text: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
choice0_enabled: bool = dataclasses.field(default=True)
choice1_enabled: bool = dataclasses.field(default=True)
choice2_enabled: bool = dataclasses.field(default=True)
choice3_enabled: bool = dataclasses.field(default=True)
cancel_enabled: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GMNU'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%\xfa).') # 0x25fa292e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text))
data.write(b'\x94\x0b\xfb\x9e') # 0x940bfb9e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.choice0_enabled))
data.write(b'\x0f\xae\xb7\xf1') # 0xfaeb7f1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.choice1_enabled))
data.write(b'x0e\x01') # 0x78306501
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.choice2_enabled))
data.write(b'\xe3\x95)n') # 0xe395296e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.choice3_enabled))
data.write(b's/\xa0\xb0') # 0x732fa0b0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.cancel_enabled))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
text=data['text'],
choice0_enabled=data['choice0_enabled'],
choice1_enabled=data['choice1_enabled'],
choice2_enabled=data['choice2_enabled'],
choice3_enabled=data['choice3_enabled'],
cancel_enabled=data['cancel_enabled'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'text': self.text,
'choice0_enabled': self.choice0_enabled,
'choice1_enabled': self.choice1_enabled,
'choice2_enabled': self.choice2_enabled,
'choice3_enabled': self.choice3_enabled,
'cancel_enabled': self.cancel_enabled,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_text(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_choice0_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_choice1_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_choice2_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_choice3_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_cancel_enabled(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x25fa292e: ('text', _decode_text),
0x940bfb9e: ('choice0_enabled', _decode_choice0_enabled),
0xfaeb7f1: ('choice1_enabled', _decode_choice1_enabled),
0x78306501: ('choice2_enabled', _decode_choice2_enabled),
0xe395296e: ('choice3_enabled', _decode_choice3_enabled),
0x732fa0b0: ('cancel_enabled', _decode_cancel_enabled),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GuiMenu.py | 0.577614 | 0.357231 | GuiMenu.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Switch(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
is_open: bool = dataclasses.field(default=False)
is_auto_close: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SWTC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\xdf\xfa\xd2') # 0xa1dffad2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_open))
data.write(b'\x05J\x1e4') # 0x54a1e34
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_auto_close))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
is_open=data['is_open'],
is_auto_close=data['is_auto_close'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'is_open': self.is_open,
'is_auto_close': self.is_auto_close,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_is_open(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_auto_close(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa1dffad2: ('is_open', _decode_is_open),
0x54a1e34: ('is_auto_close', _decode_is_auto_close),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Switch.py | 0.619817 | 0.379321 | Switch.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct18 import UnknownStruct18
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct32 import UnknownStruct32
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct33 import UnknownStruct33
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 TippyPlatform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: 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))
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
tippy_platform_module: UnknownStruct33 = dataclasses.field(default_factory=UnknownStruct33)
motion_platform_module: UnknownStruct32 = dataclasses.field(default_factory=UnknownStruct32)
unknown_struct18: UnknownStruct18 = dataclasses.field(default_factory=UnknownStruct18)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TIPI'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
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
assert data.tell() - root_size_start == 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'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf2\xd2\xc8\xe8') # 0xf2d2c8e8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tippy_platform_module.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17K]\xc1') # 0x174b5dc1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_platform_module.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\xc6\xd9\xde') # 0xa1c6d9de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct18.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
actor_information=ActorParameters.from_json(data['actor_information']),
model=data['model'],
collision_model=data['collision_model'],
animation=AnimationParameters.from_json(data['animation']),
tippy_platform_module=UnknownStruct33.from_json(data['tippy_platform_module']),
motion_platform_module=UnknownStruct32.from_json(data['motion_platform_module']),
unknown_struct18=UnknownStruct18.from_json(data['unknown_struct18']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'actor_information': self.actor_information.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'animation': self.animation.to_json(),
'tippy_platform_module': self.tippy_platform_module.to_json(),
'motion_platform_module': self.motion_platform_module.to_json(),
'unknown_struct18': self.unknown_struct18.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(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_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_tippy_platform_module(data: typing.BinaryIO, property_size: int):
return UnknownStruct33.from_stream(data, property_size)
def _decode_motion_platform_module(data: typing.BinaryIO, property_size: int):
return UnknownStruct32.from_stream(data, property_size)
def _decode_unknown_struct18(data: typing.BinaryIO, property_size: int):
return UnknownStruct18.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa3d63f44: ('animation', _decode_animation),
0xf2d2c8e8: ('tippy_platform_module', _decode_tippy_platform_module),
0x174b5dc1: ('motion_platform_module', _decode_motion_platform_module),
0xa1c6d9de: ('unknown_struct18', _decode_unknown_struct18),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TippyPlatform.py | 0.52756 | 0.286057 | TippyPlatform.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.