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
import retro_data_structures.enums.dkc_returns as enums
@dataclasses.dataclass()
class IdleBehaviorData(BaseProperty):
idle_type: enums.IdleType = dataclasses.field(default=enums.IdleType.Unknown1)
delay_before_first_idle: float = dataclasses.field(default=0.0)
first_idle_time: float = dataclasses.field(default=0.0)
delay_between_idles: float = dataclasses.field(default=0.0)
idle_time: float = dataclasses.field(default=0.0)
idle_at_start: 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\x06') # 6 properties
data.write(b'\xc9T\x9d+') # 0xc9549d2b
data.write(b'\x00\x04') # size
self.idle_type.to_stream(data)
data.write(b'$\xf6\xd9V') # 0x24f6d956
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_before_first_idle))
data.write(b'\xa3\xeb\x83$') # 0xa3eb8324
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.first_idle_time))
data.write(b'\x89\xb0z\xf3') # 0x89b07af3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_between_idles))
data.write(b'\xd1\x02\x0f,') # 0xd1020f2c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.idle_time))
data.write(b'\xbdq\xad\x8b') # 0xbd71ad8b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.idle_at_start))
@classmethod
def from_json(cls, data: dict):
return cls(
idle_type=enums.IdleType.from_json(data['idle_type']),
delay_before_first_idle=data['delay_before_first_idle'],
first_idle_time=data['first_idle_time'],
delay_between_idles=data['delay_between_idles'],
idle_time=data['idle_time'],
idle_at_start=data['idle_at_start'],
)
def to_json(self) -> dict:
return {
'idle_type': self.idle_type.to_json(),
'delay_before_first_idle': self.delay_before_first_idle,
'first_idle_time': self.first_idle_time,
'delay_between_idles': self.delay_between_idles,
'idle_time': self.idle_time,
'idle_at_start': self.idle_at_start,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc9549d2b, 0x24f6d956, 0xa3eb8324, 0x89b07af3, 0xd1020f2c, 0xbd71ad8b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[IdleBehaviorData]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHfLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(57))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return IdleBehaviorData(
enums.IdleType(dec[2]),
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_idle_type(data: typing.BinaryIO, property_size: int):
return enums.IdleType.from_stream(data)
def _decode_delay_before_first_idle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_first_idle_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_between_idles(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_idle_at_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]]] = {
0xc9549d2b: ('idle_type', _decode_idle_type),
0x24f6d956: ('delay_before_first_idle', _decode_delay_before_first_idle),
0xa3eb8324: ('first_idle_time', _decode_first_idle_time),
0x89b07af3: ('delay_between_idles', _decode_delay_between_idles),
0xd1020f2c: ('idle_time', _decode_idle_time),
0xbd71ad8b: ('idle_at_start', _decode_idle_at_start),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/IdleBehaviorData.py | 0.597608 | 0.223504 | IdleBehaviorData.py | 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 FramingRules(BaseProperty):
limit_view_to_bounds: bool = dataclasses.field(default=False)
ignore_upper_lower_bounds: bool = dataclasses.field(default=True)
bounds_buffer: float = dataclasses.field(default=2.0)
allow_zooming: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x1d(0\xc3') # 0x1d2830c3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.limit_view_to_bounds))
data.write(b'hYR\xe3') # 0x685952e3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_upper_lower_bounds))
data.write(b'\xd0\x98\x95n') # 0xd098956e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounds_buffer))
data.write(b'J.B_') # 0x4a2e425f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_zooming))
@classmethod
def from_json(cls, data: dict):
return cls(
limit_view_to_bounds=data['limit_view_to_bounds'],
ignore_upper_lower_bounds=data['ignore_upper_lower_bounds'],
bounds_buffer=data['bounds_buffer'],
allow_zooming=data['allow_zooming'],
)
def to_json(self) -> dict:
return {
'limit_view_to_bounds': self.limit_view_to_bounds,
'ignore_upper_lower_bounds': self.ignore_upper_lower_bounds,
'bounds_buffer': self.bounds_buffer,
'allow_zooming': self.allow_zooming,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1d2830c3, 0x685952e3, 0xd098956e, 0x4a2e425f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FramingRules]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(31))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return FramingRules(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_limit_view_to_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_upper_lower_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_bounds_buffer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_allow_zooming(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]]] = {
0x1d2830c3: ('limit_view_to_bounds', _decode_limit_view_to_bounds),
0x685952e3: ('ignore_upper_lower_bounds', _decode_ignore_upper_lower_bounds),
0xd098956e: ('bounds_buffer', _decode_bounds_buffer),
0x4a2e425f: ('allow_zooming', _decode_allow_zooming),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FramingRules.py | 0.643441 | 0.33135 | FramingRules.py | 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 UnknownStruct83(BaseProperty):
attack_mode: enums.AttackMode = dataclasses.field(default=enums.AttackMode.Unknown1)
number_of_stages: int = dataclasses.field(default=4)
unknown_0x8314e5ec: int = dataclasses.field(default=3)
unknown_0x8968dc43: 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\x04') # 4 properties
data.write(b'\xf8d\xfa\xd8') # 0xf864fad8
data.write(b'\x00\x04') # size
self.attack_mode.to_stream(data)
data.write(b'\x86\x97\x00\xfa') # 0x869700fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_stages))
data.write(b'\x83\x14\xe5\xec') # 0x8314e5ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8314e5ec))
data.write(b'\x89h\xdcC') # 0x8968dc43
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8968dc43))
@classmethod
def from_json(cls, data: dict):
return cls(
attack_mode=enums.AttackMode.from_json(data['attack_mode']),
number_of_stages=data['number_of_stages'],
unknown_0x8314e5ec=data['unknown_0x8314e5ec'],
unknown_0x8968dc43=data['unknown_0x8968dc43'],
)
def to_json(self) -> dict:
return {
'attack_mode': self.attack_mode.to_json(),
'number_of_stages': self.number_of_stages,
'unknown_0x8314e5ec': self.unknown_0x8314e5ec,
'unknown_0x8968dc43': self.unknown_0x8968dc43,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf864fad8, 0x869700fa, 0x8314e5ec, 0x8968dc43)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct83]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHlLHlLHf')
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 UnknownStruct83(
enums.AttackMode(dec[2]),
dec[5],
dec[8],
dec[11],
)
def _decode_attack_mode(data: typing.BinaryIO, property_size: int):
return enums.AttackMode.from_stream(data)
def _decode_number_of_stages(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x8314e5ec(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x8968dc43(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]]] = {
0xf864fad8: ('attack_mode', _decode_attack_mode),
0x869700fa: ('number_of_stages', _decode_number_of_stages),
0x8314e5ec: ('unknown_0x8314e5ec', _decode_unknown_0x8314e5ec),
0x8968dc43: ('unknown_0x8968dc43', _decode_unknown_0x8968dc43),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct83.py | 0.600071 | 0.265547 | UnknownStruct83.py | 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 StunnedByContactRuleData(BaseProperty):
stun_duration: float = dataclasses.field(default=3.0)
apply_boost_after_stun: bool = dataclasses.field(default=False)
boost_duration: float = dataclasses.field(default=5.0)
boost_speed_modifier: float = dataclasses.field(default=1.0)
can_be_blown: 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\x05') # 5 properties
data.write(b'-\x8d\xb3\x1d') # 0x2d8db31d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_duration))
data.write(b'\x19wy\xd1') # 0x197779d1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_boost_after_stun))
data.write(b'\xbaIr\xfe') # 0xba4972fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_duration))
data.write(b'\x85\xd3\x9c\xb7') # 0x85d39cb7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.boost_speed_modifier))
data.write(b'\xf6N8g') # 0xf64e3867
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_blown))
@classmethod
def from_json(cls, data: dict):
return cls(
stun_duration=data['stun_duration'],
apply_boost_after_stun=data['apply_boost_after_stun'],
boost_duration=data['boost_duration'],
boost_speed_modifier=data['boost_speed_modifier'],
can_be_blown=data['can_be_blown'],
)
def to_json(self) -> dict:
return {
'stun_duration': self.stun_duration,
'apply_boost_after_stun': self.apply_boost_after_stun,
'boost_duration': self.boost_duration,
'boost_speed_modifier': self.boost_speed_modifier,
'can_be_blown': self.can_be_blown,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2d8db31d, 0x197779d1, 0xba4972fe, 0x85d39cb7, 0xf64e3867)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[StunnedByContactRuleData]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?LHfLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(44))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return StunnedByContactRuleData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_stun_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_apply_boost_after_stun(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_boost_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_boost_speed_modifier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_can_be_blown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2d8db31d: ('stun_duration', _decode_stun_duration),
0x197779d1: ('apply_boost_after_stun', _decode_apply_boost_after_stun),
0xba4972fe: ('boost_duration', _decode_boost_duration),
0x85d39cb7: ('boost_speed_modifier', _decode_boost_speed_modifier),
0xf64e3867: ('can_be_blown', _decode_can_be_blown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/StunnedByContactRuleData.py | 0.61451 | 0.283532 | StunnedByContactRuleData.py | 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 CheckpointData(BaseProperty):
used_for_respawn: bool = dataclasses.field(default=True)
always_active: bool = dataclasses.field(default=False)
priority: int = dataclasses.field(default=0)
respawn_break_bounds: float = dataclasses.field(default=3.0)
use_balloon: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\x17\x8e\xabW') # 0x178eab57
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.used_for_respawn))
data.write(b'\xcc\xb3\x12\xc3') # 0xccb312c3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.always_active))
data.write(b'B\x08vP') # 0x42087650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.priority))
data.write(b'\xfe[\xbe\xc8') # 0xfe5bbec8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.respawn_break_bounds))
data.write(b'a\xaa\x81\x9f') # 0x61aa819f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_balloon))
@classmethod
def from_json(cls, data: dict):
return cls(
used_for_respawn=data['used_for_respawn'],
always_active=data['always_active'],
priority=data['priority'],
respawn_break_bounds=data['respawn_break_bounds'],
use_balloon=data['use_balloon'],
)
def to_json(self) -> dict:
return {
'used_for_respawn': self.used_for_respawn,
'always_active': self.always_active,
'priority': self.priority,
'respawn_break_bounds': self.respawn_break_bounds,
'use_balloon': self.use_balloon,
}
_FAST_FORMAT = None
_FAST_IDS = (0x178eab57, 0xccb312c3, 0x42087650, 0xfe5bbec8, 0x61aa819f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CheckpointData]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHlLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(41))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return CheckpointData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_used_for_respawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_always_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_respawn_break_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_balloon(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]]] = {
0x178eab57: ('used_for_respawn', _decode_used_for_respawn),
0xccb312c3: ('always_active', _decode_always_active),
0x42087650: ('priority', _decode_priority),
0xfe5bbec8: ('respawn_break_bounds', _decode_respawn_break_bounds),
0x61aa819f: ('use_balloon', _decode_use_balloon),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CheckpointData.py | 0.623033 | 0.272613 | CheckpointData.py | 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 UnknownStruct132(BaseProperty):
unknown_0x041b3c2b: Vector = dataclasses.field(default_factory=lambda: Vector(x=10.606200218200684, y=21.21269989013672, z=18.371999740600586))
unknown_0x599eacd6: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.5, y=21.21269989013672, z=18.371999740600586))
minimum_spin_speed: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=13.0, z=0.0))
maximum_spin_speed: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=15.0, z=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x04\x1b<+') # 0x41b3c2b
data.write(b'\x00\x0c') # size
self.unknown_0x041b3c2b.to_stream(data)
data.write(b'Y\x9e\xac\xd6') # 0x599eacd6
data.write(b'\x00\x0c') # size
self.unknown_0x599eacd6.to_stream(data)
data.write(b'\xf7\x8c\x8a\xc7') # 0xf78c8ac7
data.write(b'\x00\x0c') # size
self.minimum_spin_speed.to_stream(data)
data.write(b'\xb6\x9b\xb5A') # 0xb69bb541
data.write(b'\x00\x0c') # size
self.maximum_spin_speed.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x041b3c2b=Vector.from_json(data['unknown_0x041b3c2b']),
unknown_0x599eacd6=Vector.from_json(data['unknown_0x599eacd6']),
minimum_spin_speed=Vector.from_json(data['minimum_spin_speed']),
maximum_spin_speed=Vector.from_json(data['maximum_spin_speed']),
)
def to_json(self) -> dict:
return {
'unknown_0x041b3c2b': self.unknown_0x041b3c2b.to_json(),
'unknown_0x599eacd6': self.unknown_0x599eacd6.to_json(),
'minimum_spin_speed': self.minimum_spin_speed.to_json(),
'maximum_spin_speed': self.maximum_spin_speed.to_json(),
}
def _decode_unknown_0x041b3c2b(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x599eacd6(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_minimum_spin_speed(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_maximum_spin_speed(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x41b3c2b: ('unknown_0x041b3c2b', _decode_unknown_0x041b3c2b),
0x599eacd6: ('unknown_0x599eacd6', _decode_unknown_0x599eacd6),
0xf78c8ac7: ('minimum_spin_speed', _decode_minimum_spin_speed),
0xb69bb541: ('maximum_spin_speed', _decode_maximum_spin_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct132.py | 0.778733 | 0.360039 | UnknownStruct132.py | 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.UnknownStruct165 import UnknownStruct165
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct166 import UnknownStruct166
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct168 import UnknownStruct168
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct169 import UnknownStruct169
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct174 import UnknownStruct174
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct175 import UnknownStruct175
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct176 import UnknownStruct176
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct177 import UnknownStruct177
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct178 import UnknownStruct178
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct179 import UnknownStruct179
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct180 import UnknownStruct180
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct181 import UnknownStruct181
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct34 import UnknownStruct34
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct35 import UnknownStruct35
@dataclasses.dataclass()
class UnknownStruct182(BaseProperty):
unknown_struct35: UnknownStruct35 = dataclasses.field(default_factory=UnknownStruct35)
unknown_struct165: UnknownStruct165 = dataclasses.field(default_factory=UnknownStruct165)
unknown_struct166: UnknownStruct166 = dataclasses.field(default_factory=UnknownStruct166)
unknown_struct168: UnknownStruct168 = dataclasses.field(default_factory=UnknownStruct168)
unknown_struct169: UnknownStruct169 = dataclasses.field(default_factory=UnknownStruct169)
unknown_struct174: UnknownStruct174 = dataclasses.field(default_factory=UnknownStruct174)
unknown_struct175: UnknownStruct175 = dataclasses.field(default_factory=UnknownStruct175)
unknown_struct176: UnknownStruct176 = dataclasses.field(default_factory=UnknownStruct176)
unknown_struct177: UnknownStruct177 = dataclasses.field(default_factory=UnknownStruct177)
unknown_struct34: UnknownStruct34 = dataclasses.field(default_factory=UnknownStruct34)
unknown_struct178: UnknownStruct178 = dataclasses.field(default_factory=UnknownStruct178)
unknown_struct179: UnknownStruct179 = dataclasses.field(default_factory=UnknownStruct179)
unknown_struct180: UnknownStruct180 = dataclasses.field(default_factory=UnknownStruct180)
unknown_struct181: UnknownStruct181 = dataclasses.field(default_factory=UnknownStruct181)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xd8U$\xdb') # 0xd85524db
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct35.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xba\xb9\x07Y') # 0xbab90759
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct165.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9gE\x17') # 0xf9674517
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct166.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b',y\x16\xec') # 0x2c7916ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct168.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'L\xeaS\xf4') # 0x4cea53f4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct169.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x90\xa6\xae\x10') # 0x90a6ae10
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct174.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'cb\xf9\x10') # 0x6362f910
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct175.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7(f\xd4') # 0x372866d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct176.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea/u\n') # 0xea2f750a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct177.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\xad\xb9h') # 0x51adb968
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)
data.write(b'\xd8\xba\x1e\x9a') # 0xd8ba1e9a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct178.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*\xa4\x87#') # 0x2aa48723
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct179.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6Gl}') # 0xc6476c7d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct180.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc#y\xa9') # 0xbc2379a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct181.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_struct35=UnknownStruct35.from_json(data['unknown_struct35']),
unknown_struct165=UnknownStruct165.from_json(data['unknown_struct165']),
unknown_struct166=UnknownStruct166.from_json(data['unknown_struct166']),
unknown_struct168=UnknownStruct168.from_json(data['unknown_struct168']),
unknown_struct169=UnknownStruct169.from_json(data['unknown_struct169']),
unknown_struct174=UnknownStruct174.from_json(data['unknown_struct174']),
unknown_struct175=UnknownStruct175.from_json(data['unknown_struct175']),
unknown_struct176=UnknownStruct176.from_json(data['unknown_struct176']),
unknown_struct177=UnknownStruct177.from_json(data['unknown_struct177']),
unknown_struct34=UnknownStruct34.from_json(data['unknown_struct34']),
unknown_struct178=UnknownStruct178.from_json(data['unknown_struct178']),
unknown_struct179=UnknownStruct179.from_json(data['unknown_struct179']),
unknown_struct180=UnknownStruct180.from_json(data['unknown_struct180']),
unknown_struct181=UnknownStruct181.from_json(data['unknown_struct181']),
)
def to_json(self) -> dict:
return {
'unknown_struct35': self.unknown_struct35.to_json(),
'unknown_struct165': self.unknown_struct165.to_json(),
'unknown_struct166': self.unknown_struct166.to_json(),
'unknown_struct168': self.unknown_struct168.to_json(),
'unknown_struct169': self.unknown_struct169.to_json(),
'unknown_struct174': self.unknown_struct174.to_json(),
'unknown_struct175': self.unknown_struct175.to_json(),
'unknown_struct176': self.unknown_struct176.to_json(),
'unknown_struct177': self.unknown_struct177.to_json(),
'unknown_struct34': self.unknown_struct34.to_json(),
'unknown_struct178': self.unknown_struct178.to_json(),
'unknown_struct179': self.unknown_struct179.to_json(),
'unknown_struct180': self.unknown_struct180.to_json(),
'unknown_struct181': self.unknown_struct181.to_json(),
}
def _decode_unknown_struct35(data: typing.BinaryIO, property_size: int):
return UnknownStruct35.from_stream(data, property_size)
def _decode_unknown_struct165(data: typing.BinaryIO, property_size: int):
return UnknownStruct165.from_stream(data, property_size)
def _decode_unknown_struct166(data: typing.BinaryIO, property_size: int):
return UnknownStruct166.from_stream(data, property_size)
def _decode_unknown_struct168(data: typing.BinaryIO, property_size: int):
return UnknownStruct168.from_stream(data, property_size)
def _decode_unknown_struct169(data: typing.BinaryIO, property_size: int):
return UnknownStruct169.from_stream(data, property_size)
def _decode_unknown_struct174(data: typing.BinaryIO, property_size: int):
return UnknownStruct174.from_stream(data, property_size)
def _decode_unknown_struct175(data: typing.BinaryIO, property_size: int):
return UnknownStruct175.from_stream(data, property_size)
def _decode_unknown_struct176(data: typing.BinaryIO, property_size: int):
return UnknownStruct176.from_stream(data, property_size)
def _decode_unknown_struct177(data: typing.BinaryIO, property_size: int):
return UnknownStruct177.from_stream(data, property_size)
def _decode_unknown_struct34(data: typing.BinaryIO, property_size: int):
return UnknownStruct34.from_stream(data, property_size)
def _decode_unknown_struct178(data: typing.BinaryIO, property_size: int):
return UnknownStruct178.from_stream(data, property_size)
def _decode_unknown_struct179(data: typing.BinaryIO, property_size: int):
return UnknownStruct179.from_stream(data, property_size)
def _decode_unknown_struct180(data: typing.BinaryIO, property_size: int):
return UnknownStruct180.from_stream(data, property_size)
def _decode_unknown_struct181(data: typing.BinaryIO, property_size: int):
return UnknownStruct181.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd85524db: ('unknown_struct35', _decode_unknown_struct35),
0xbab90759: ('unknown_struct165', _decode_unknown_struct165),
0xf9674517: ('unknown_struct166', _decode_unknown_struct166),
0x2c7916ec: ('unknown_struct168', _decode_unknown_struct168),
0x4cea53f4: ('unknown_struct169', _decode_unknown_struct169),
0x90a6ae10: ('unknown_struct174', _decode_unknown_struct174),
0x6362f910: ('unknown_struct175', _decode_unknown_struct175),
0x372866d4: ('unknown_struct176', _decode_unknown_struct176),
0xea2f750a: ('unknown_struct177', _decode_unknown_struct177),
0x51adb968: ('unknown_struct34', _decode_unknown_struct34),
0xd8ba1e9a: ('unknown_struct178', _decode_unknown_struct178),
0x2aa48723: ('unknown_struct179', _decode_unknown_struct179),
0xc6476c7d: ('unknown_struct180', _decode_unknown_struct180),
0xbc2379a9: ('unknown_struct181', _decode_unknown_struct181),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct182.py | 0.500488 | 0.207958 | UnknownStruct182.py | 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 VelocityConvergence(BaseProperty):
max_speed: float = dataclasses.field(default=0.0)
acceleration: float = dataclasses.field(default=0.0)
dampening_range: 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'\x82\xdb\x0c\xbe') # 0x82db0cbe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_speed))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x1a\x11\x17%') # 0x1a111725
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dampening_range))
@classmethod
def from_json(cls, data: dict):
return cls(
max_speed=data['max_speed'],
acceleration=data['acceleration'],
dampening_range=data['dampening_range'],
)
def to_json(self) -> dict:
return {
'max_speed': self.max_speed,
'acceleration': self.acceleration,
'dampening_range': self.dampening_range,
}
_FAST_FORMAT = None
_FAST_IDS = (0x82db0cbe, 0x39fb7978, 0x1a111725)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VelocityConvergence]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return VelocityConvergence(
dec[2],
dec[5],
dec[8],
)
def _decode_max_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dampening_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x82db0cbe: ('max_speed', _decode_max_speed),
0x39fb7978: ('acceleration', _decode_acceleration),
0x1a111725: ('dampening_range', _decode_dampening_range),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VelocityConvergence.py | 0.744006 | 0.353289 | VelocityConvergence.py | 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.RagDollData import RagDollData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class CableProperties(BaseProperty):
cable_segment_effect: AssetId = dataclasses.field(metadata={'asset_types': ['SWHC']}, default=default_asset_id)
cable_lighting: enums.CableLighting = dataclasses.field(default=enums.CableLighting.Unknown1)
cable_type: enums.CableType = dataclasses.field(default=enums.CableType.Unknown2)
spline_type: enums.SplineType = dataclasses.field(default=enums.SplineType.Unknown1)
unknown_0xb6a06760: bool = dataclasses.field(default=False)
num_segments: int = dataclasses.field(default=10)
min_burn_rate: float = dataclasses.field(default=4.0)
max_burn_rate: float = dataclasses.field(default=4.0)
location_of_effect1: enums.CableEnum = dataclasses.field(default=enums.CableEnum.Unknown1)
location_of_effect2: enums.CableEnum = dataclasses.field(default=enums.CableEnum.Unknown3)
location_of_effect3: enums.CableEnum = dataclasses.field(default=enums.CableEnum.Unknown2)
unknown_0x833e4985: float = dataclasses.field(default=1.0)
is_shootable: bool = dataclasses.field(default=False)
is_generated: bool = dataclasses.field(default=False)
rag_doll_data: RagDollData = dataclasses.field(default_factory=RagDollData)
impulse_magnitude: float = dataclasses.field(default=0.0)
impulse_frequency: float = dataclasses.field(default=15.0)
impulse_duration: float = dataclasses.field(default=0.016699999570846558)
impulse_location: enums.ImpulseLocation = dataclasses.field(default=enums.ImpulseLocation.Unknown2)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'\xff\xe8;w') # 0xffe83b77
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cable_segment_effect))
data.write(b':\xfb\xe3\x00') # 0x3afbe300
data.write(b'\x00\x04') # size
self.cable_lighting.to_stream(data)
data.write(b'K:\x87\xe6') # 0x4b3a87e6
data.write(b'\x00\x04') # size
self.cable_type.to_stream(data)
data.write(b'\xcdW\x81\x93') # 0xcd578193
data.write(b'\x00\x04') # size
self.spline_type.to_stream(data)
data.write(b'\xb6\xa0g`') # 0xb6a06760
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb6a06760))
data.write(b'e\x86\xec\x98') # 0x6586ec98
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_segments))
data.write(b'@^\x8fU') # 0x405e8f55
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_burn_rate))
data.write(b'\x11\xa74\x08') # 0x11a73408
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_burn_rate))
data.write(b'D\xefM\xab') # 0x44ef4dab
data.write(b'\x00\x04') # size
self.location_of_effect1.to_stream(data)
data.write(b'\x03O7{') # 0x34f377b
data.write(b'\x00\x04') # size
self.location_of_effect2.to_stream(data)
data.write(b'>/\x1e\xcb') # 0x3e2f1ecb
data.write(b'\x00\x04') # size
self.location_of_effect3.to_stream(data)
data.write(b'\x83>I\x85') # 0x833e4985
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x833e4985))
data.write(b'\x8cs\xcb|') # 0x8c73cb7c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_shootable))
data.write(b'\xdd\xb5\xe1\xd1') # 0xddb5e1d1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_generated))
data.write(b'\x84\x848\x07') # 0x84843807
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rag_doll_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'j\xd5]P') # 0x6ad55d50
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impulse_magnitude))
data.write(b'\xeb^\xe4|') # 0xeb5ee47c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impulse_frequency))
data.write(b'\xc2]\xc1\xb8') # 0xc25dc1b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impulse_duration))
data.write(b'\xa0\xad\xd2\xdf') # 0xa0add2df
data.write(b'\x00\x04') # size
self.impulse_location.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
cable_segment_effect=data['cable_segment_effect'],
cable_lighting=enums.CableLighting.from_json(data['cable_lighting']),
cable_type=enums.CableType.from_json(data['cable_type']),
spline_type=enums.SplineType.from_json(data['spline_type']),
unknown_0xb6a06760=data['unknown_0xb6a06760'],
num_segments=data['num_segments'],
min_burn_rate=data['min_burn_rate'],
max_burn_rate=data['max_burn_rate'],
location_of_effect1=enums.CableEnum.from_json(data['location_of_effect1']),
location_of_effect2=enums.CableEnum.from_json(data['location_of_effect2']),
location_of_effect3=enums.CableEnum.from_json(data['location_of_effect3']),
unknown_0x833e4985=data['unknown_0x833e4985'],
is_shootable=data['is_shootable'],
is_generated=data['is_generated'],
rag_doll_data=RagDollData.from_json(data['rag_doll_data']),
impulse_magnitude=data['impulse_magnitude'],
impulse_frequency=data['impulse_frequency'],
impulse_duration=data['impulse_duration'],
impulse_location=enums.ImpulseLocation.from_json(data['impulse_location']),
)
def to_json(self) -> dict:
return {
'cable_segment_effect': self.cable_segment_effect,
'cable_lighting': self.cable_lighting.to_json(),
'cable_type': self.cable_type.to_json(),
'spline_type': self.spline_type.to_json(),
'unknown_0xb6a06760': self.unknown_0xb6a06760,
'num_segments': self.num_segments,
'min_burn_rate': self.min_burn_rate,
'max_burn_rate': self.max_burn_rate,
'location_of_effect1': self.location_of_effect1.to_json(),
'location_of_effect2': self.location_of_effect2.to_json(),
'location_of_effect3': self.location_of_effect3.to_json(),
'unknown_0x833e4985': self.unknown_0x833e4985,
'is_shootable': self.is_shootable,
'is_generated': self.is_generated,
'rag_doll_data': self.rag_doll_data.to_json(),
'impulse_magnitude': self.impulse_magnitude,
'impulse_frequency': self.impulse_frequency,
'impulse_duration': self.impulse_duration,
'impulse_location': self.impulse_location.to_json(),
}
def _decode_cable_segment_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cable_lighting(data: typing.BinaryIO, property_size: int):
return enums.CableLighting.from_stream(data)
def _decode_cable_type(data: typing.BinaryIO, property_size: int):
return enums.CableType.from_stream(data)
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return enums.SplineType.from_stream(data)
def _decode_unknown_0xb6a06760(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_num_segments(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_min_burn_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_burn_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_location_of_effect1(data: typing.BinaryIO, property_size: int):
return enums.CableEnum.from_stream(data)
def _decode_location_of_effect2(data: typing.BinaryIO, property_size: int):
return enums.CableEnum.from_stream(data)
def _decode_location_of_effect3(data: typing.BinaryIO, property_size: int):
return enums.CableEnum.from_stream(data)
def _decode_unknown_0x833e4985(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_shootable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_generated(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rag_doll_data(data: typing.BinaryIO, property_size: int):
return RagDollData.from_stream(data, property_size)
def _decode_impulse_magnitude(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impulse_frequency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impulse_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impulse_location(data: typing.BinaryIO, property_size: int):
return enums.ImpulseLocation.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xffe83b77: ('cable_segment_effect', _decode_cable_segment_effect),
0x3afbe300: ('cable_lighting', _decode_cable_lighting),
0x4b3a87e6: ('cable_type', _decode_cable_type),
0xcd578193: ('spline_type', _decode_spline_type),
0xb6a06760: ('unknown_0xb6a06760', _decode_unknown_0xb6a06760),
0x6586ec98: ('num_segments', _decode_num_segments),
0x405e8f55: ('min_burn_rate', _decode_min_burn_rate),
0x11a73408: ('max_burn_rate', _decode_max_burn_rate),
0x44ef4dab: ('location_of_effect1', _decode_location_of_effect1),
0x34f377b: ('location_of_effect2', _decode_location_of_effect2),
0x3e2f1ecb: ('location_of_effect3', _decode_location_of_effect3),
0x833e4985: ('unknown_0x833e4985', _decode_unknown_0x833e4985),
0x8c73cb7c: ('is_shootable', _decode_is_shootable),
0xddb5e1d1: ('is_generated', _decode_is_generated),
0x84843807: ('rag_doll_data', _decode_rag_doll_data),
0x6ad55d50: ('impulse_magnitude', _decode_impulse_magnitude),
0xeb5ee47c: ('impulse_frequency', _decode_impulse_frequency),
0xc25dc1b8: ('impulse_duration', _decode_impulse_duration),
0xa0add2df: ('impulse_location', _decode_impulse_location),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CableProperties.py | 0.556279 | 0.275912 | CableProperties.py | 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 FollowSurfaceBehaviorData(BaseProperty):
snap_lerp_value: float = dataclasses.field(default=0.10000000149011612)
start_turn_distance: float = dataclasses.field(default=0.0)
use_terrain_neighbor_influences: bool = dataclasses.field(default=False)
detached_by_ground_pound: bool = dataclasses.field(default=False)
change_contact_rules_when_tilted: bool = dataclasses.field(default=False)
tilt_threshold: float = dataclasses.field(default=0.800000011920929)
contact_rules: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
override_collision_radius: bool = dataclasses.field(default=False)
alignment_radius: 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\t') # 9 properties
data.write(b'\x9a\x83\xf4r') # 0x9a83f472
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.snap_lerp_value))
data.write(b'\xf5r%k') # 0xf572256b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_turn_distance))
data.write(b'\xa8c\xba\xe2') # 0xa863bae2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_terrain_neighbor_influences))
data.write(b'W\xe4\r\xc7') # 0x57e40dc7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.detached_by_ground_pound))
data.write(b'\x10/\x9f\x94') # 0x102f9f94
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.change_contact_rules_when_tilted))
data.write(b'\xa7-\xfc^') # 0xa72dfc5e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tilt_threshold))
data.write(b'\x01\x9f\xf3b') # 0x19ff362
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.contact_rules))
data.write(b'\t\xa866') # 0x9a83636
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override_collision_radius))
data.write(b'\xf7&\x06\x9b') # 0xf726069b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alignment_radius))
@classmethod
def from_json(cls, data: dict):
return cls(
snap_lerp_value=data['snap_lerp_value'],
start_turn_distance=data['start_turn_distance'],
use_terrain_neighbor_influences=data['use_terrain_neighbor_influences'],
detached_by_ground_pound=data['detached_by_ground_pound'],
change_contact_rules_when_tilted=data['change_contact_rules_when_tilted'],
tilt_threshold=data['tilt_threshold'],
contact_rules=data['contact_rules'],
override_collision_radius=data['override_collision_radius'],
alignment_radius=data['alignment_radius'],
)
def to_json(self) -> dict:
return {
'snap_lerp_value': self.snap_lerp_value,
'start_turn_distance': self.start_turn_distance,
'use_terrain_neighbor_influences': self.use_terrain_neighbor_influences,
'detached_by_ground_pound': self.detached_by_ground_pound,
'change_contact_rules_when_tilted': self.change_contact_rules_when_tilted,
'tilt_threshold': self.tilt_threshold,
'contact_rules': self.contact_rules,
'override_collision_radius': self.override_collision_radius,
'alignment_radius': self.alignment_radius,
}
_FAST_FORMAT = None
_FAST_IDS = (0x9a83f472, 0xf572256b, 0xa863bae2, 0x57e40dc7, 0x102f9f94, 0xa72dfc5e, 0x19ff362, 0x9a83636, 0xf726069b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FollowSurfaceBehaviorData]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLH?LH?LH?LHfLHQLH?LHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(82))
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 FollowSurfaceBehaviorData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_snap_lerp_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_turn_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_terrain_neighbor_influences(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_detached_by_ground_pound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_change_contact_rules_when_tilted(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_tilt_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_contact_rules(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_override_collision_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_alignment_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]]] = {
0x9a83f472: ('snap_lerp_value', _decode_snap_lerp_value),
0xf572256b: ('start_turn_distance', _decode_start_turn_distance),
0xa863bae2: ('use_terrain_neighbor_influences', _decode_use_terrain_neighbor_influences),
0x57e40dc7: ('detached_by_ground_pound', _decode_detached_by_ground_pound),
0x102f9f94: ('change_contact_rules_when_tilted', _decode_change_contact_rules_when_tilted),
0xa72dfc5e: ('tilt_threshold', _decode_tilt_threshold),
0x19ff362: ('contact_rules', _decode_contact_rules),
0x9a83636: ('override_collision_radius', _decode_override_collision_radius),
0xf726069b: ('alignment_radius', _decode_alignment_radius),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FollowSurfaceBehaviorData.py | 0.645008 | 0.290132 | FollowSurfaceBehaviorData.py | 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.UnknownStruct287 import UnknownStruct287
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct288 import UnknownStruct288
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct290 import UnknownStruct290
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct291 import UnknownStruct291
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct292 import UnknownStruct292
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct295 import UnknownStruct295
@dataclasses.dataclass()
class UnknownStruct296(BaseProperty):
unknown_struct287: UnknownStruct287 = dataclasses.field(default_factory=UnknownStruct287)
unknown_struct288: UnknownStruct288 = dataclasses.field(default_factory=UnknownStruct288)
unknown_struct290: UnknownStruct290 = dataclasses.field(default_factory=UnknownStruct290)
unknown_struct291: UnknownStruct291 = dataclasses.field(default_factory=UnknownStruct291)
unknown_struct292: UnknownStruct292 = dataclasses.field(default_factory=UnknownStruct292)
unknown_struct295: UnknownStruct295 = dataclasses.field(default_factory=UnknownStruct295)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'J\xe8R=') # 0x4ae8523d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct287.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*Dqf') # 0x2a447166
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct288.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdd\\p\x83') # 0xdd5c7083
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct290.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe6\x85s(') # 0xe6857328
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct291.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+S\x1c/') # 0x2b531c2f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct292.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"\x91'\xfb\xc8") # 0x9127fbc8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct295.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_struct287=UnknownStruct287.from_json(data['unknown_struct287']),
unknown_struct288=UnknownStruct288.from_json(data['unknown_struct288']),
unknown_struct290=UnknownStruct290.from_json(data['unknown_struct290']),
unknown_struct291=UnknownStruct291.from_json(data['unknown_struct291']),
unknown_struct292=UnknownStruct292.from_json(data['unknown_struct292']),
unknown_struct295=UnknownStruct295.from_json(data['unknown_struct295']),
)
def to_json(self) -> dict:
return {
'unknown_struct287': self.unknown_struct287.to_json(),
'unknown_struct288': self.unknown_struct288.to_json(),
'unknown_struct290': self.unknown_struct290.to_json(),
'unknown_struct291': self.unknown_struct291.to_json(),
'unknown_struct292': self.unknown_struct292.to_json(),
'unknown_struct295': self.unknown_struct295.to_json(),
}
def _decode_unknown_struct287(data: typing.BinaryIO, property_size: int):
return UnknownStruct287.from_stream(data, property_size)
def _decode_unknown_struct288(data: typing.BinaryIO, property_size: int):
return UnknownStruct288.from_stream(data, property_size)
def _decode_unknown_struct290(data: typing.BinaryIO, property_size: int):
return UnknownStruct290.from_stream(data, property_size)
def _decode_unknown_struct291(data: typing.BinaryIO, property_size: int):
return UnknownStruct291.from_stream(data, property_size)
def _decode_unknown_struct292(data: typing.BinaryIO, property_size: int):
return UnknownStruct292.from_stream(data, property_size)
def _decode_unknown_struct295(data: typing.BinaryIO, property_size: int):
return UnknownStruct295.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x4ae8523d: ('unknown_struct287', _decode_unknown_struct287),
0x2a447166: ('unknown_struct288', _decode_unknown_struct288),
0xdd5c7083: ('unknown_struct290', _decode_unknown_struct290),
0xe6857328: ('unknown_struct291', _decode_unknown_struct291),
0x2b531c2f: ('unknown_struct292', _decode_unknown_struct292),
0x9127fbc8: ('unknown_struct295', _decode_unknown_struct295),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct296.py | 0.644337 | 0.273864 | UnknownStruct296.py | 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 WanderRandomTurnData(BaseProperty):
min_time_till_turn: float = dataclasses.field(default=2.0)
max_time_till_turn: float = dataclasses.field(default=5.0)
time_to_disable_turn_after_collision: float = dataclasses.field(default=4.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'3\x9c\xf3\x14') # 0x339cf314
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_time_till_turn))
data.write(b'\x1a\xe2\x0e\x0c') # 0x1ae20e0c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_time_till_turn))
data.write(b'T\xd6\\\xdc') # 0x54d65cdc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_to_disable_turn_after_collision))
@classmethod
def from_json(cls, data: dict):
return cls(
min_time_till_turn=data['min_time_till_turn'],
max_time_till_turn=data['max_time_till_turn'],
time_to_disable_turn_after_collision=data['time_to_disable_turn_after_collision'],
)
def to_json(self) -> dict:
return {
'min_time_till_turn': self.min_time_till_turn,
'max_time_till_turn': self.max_time_till_turn,
'time_to_disable_turn_after_collision': self.time_to_disable_turn_after_collision,
}
_FAST_FORMAT = None
_FAST_IDS = (0x339cf314, 0x1ae20e0c, 0x54d65cdc)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[WanderRandomTurnData]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return WanderRandomTurnData(
dec[2],
dec[5],
dec[8],
)
def _decode_min_time_till_turn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_time_till_turn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_to_disable_turn_after_collision(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]]] = {
0x339cf314: ('min_time_till_turn', _decode_min_time_till_turn),
0x1ae20e0c: ('max_time_till_turn', _decode_max_time_till_turn),
0x54d65cdc: ('time_to_disable_turn_after_collision', _decode_time_to_disable_turn_after_collision),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/WanderRandomTurnData.py | 0.625781 | 0.359448 | WanderRandomTurnData.py | 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 SeekerBehaviorData(BaseProperty):
mode: int = dataclasses.field(default=3821732504) # Choice
seek_when_behavior_inactive: bool = dataclasses.field(default=False)
attack_range_squared: float = dataclasses.field(default=0.0)
speed: float = dataclasses.field(default=5.0)
acceleration: float = dataclasses.field(default=1.0)
deceleration: float = dataclasses.field(default=1.0)
turn_speed_radians: float = dataclasses.field(default=0.0)
hover_speed_threshold: float = dataclasses.field(default=0.30000001192092896)
ignore_all_but_player: bool = dataclasses.field(default=True)
ignore_all_during_death: bool = dataclasses.field(default=True)
suicide_on_player_touch: bool = dataclasses.field(default=True)
disable_collision_time_after_creation: float = dataclasses.field(default=0.0)
life_time: float = dataclasses.field(default=120.0)
max_distance_from_origin_squared: float = dataclasses.field(default=0.0)
targeting_time: float = dataclasses.field(default=0.5)
telegraph_time: float = dataclasses.field(default=0.25)
pause_time: float = dataclasses.field(default=1.0)
stop_distance_squared: float = dataclasses.field(default=0.0)
stop_speed: float = dataclasses.field(default=0.0)
flight_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
flight_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
flight_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
flight_sound_volume: Spline = dataclasses.field(default_factory=Spline)
maximum_speed_for_audio_inverse: float = dataclasses.field(default=0.0)
flight_sound_deceleration_k: 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\x19') # 25 properties
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.mode))
data.write(b'tZ\x8f\x03') # 0x745a8f03
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.seek_when_behavior_inactive))
data.write(b'\xde[\xfca') # 0xde5bfc61
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_range_squared))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
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'X\x9av\xff') # 0x589a76ff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed_radians))
data.write(b'3+U\x18') # 0x332b5518
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_speed_threshold))
data.write(b'\xab\x0fQX') # 0xab0f5158
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_all_but_player))
data.write(b'\x88Is\xd2') # 0x884973d2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_all_during_death))
data.write(b'\xba\xc8\x0e\x1f') # 0xbac80e1f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.suicide_on_player_touch))
data.write(b'\xbe\xc9\x90\x05') # 0xbec99005
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_collision_time_after_creation))
data.write(b'\xb0-\xe5U') # 0xb02de555
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.life_time))
data.write(b'\t(X\x0f') # 0x928580f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_distance_from_origin_squared))
data.write(b'\xd9L9T') # 0xd94c3954
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.targeting_time))
data.write(b'\x8ek\xbe\xf1') # 0x8e6bbef1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.telegraph_time))
data.write(b'k\x08\xf2\xf2') # 0x6b08f2f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause_time))
data.write(b'H\xb4Y\x11') # 0x48b45911
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stop_distance_squared))
data.write(b'\xd4`\x08!') # 0xd4600821
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stop_speed))
data.write(b'\xe1\xe6k$') # 0xe1e66b24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.flight_sound))
data.write(b'\xb4\x13\xc4_') # 0xb413c45f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\xc7FL') # 0x76c7464c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10\xe0Z\xaf') # 0x10e05aaf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbd\xa0\xb3\xf2') # 0xbda0b3f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed_for_audio_inverse))
data.write(b'z}\xf6\xe3') # 0x7a7df6e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.flight_sound_deceleration_k))
@classmethod
def from_json(cls, data: dict):
return cls(
mode=data['mode'],
seek_when_behavior_inactive=data['seek_when_behavior_inactive'],
attack_range_squared=data['attack_range_squared'],
speed=data['speed'],
acceleration=data['acceleration'],
deceleration=data['deceleration'],
turn_speed_radians=data['turn_speed_radians'],
hover_speed_threshold=data['hover_speed_threshold'],
ignore_all_but_player=data['ignore_all_but_player'],
ignore_all_during_death=data['ignore_all_during_death'],
suicide_on_player_touch=data['suicide_on_player_touch'],
disable_collision_time_after_creation=data['disable_collision_time_after_creation'],
life_time=data['life_time'],
max_distance_from_origin_squared=data['max_distance_from_origin_squared'],
targeting_time=data['targeting_time'],
telegraph_time=data['telegraph_time'],
pause_time=data['pause_time'],
stop_distance_squared=data['stop_distance_squared'],
stop_speed=data['stop_speed'],
flight_sound=data['flight_sound'],
flight_sound_low_pass_filter=Spline.from_json(data['flight_sound_low_pass_filter']),
flight_sound_pitch=Spline.from_json(data['flight_sound_pitch']),
flight_sound_volume=Spline.from_json(data['flight_sound_volume']),
maximum_speed_for_audio_inverse=data['maximum_speed_for_audio_inverse'],
flight_sound_deceleration_k=data['flight_sound_deceleration_k'],
)
def to_json(self) -> dict:
return {
'mode': self.mode,
'seek_when_behavior_inactive': self.seek_when_behavior_inactive,
'attack_range_squared': self.attack_range_squared,
'speed': self.speed,
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'turn_speed_radians': self.turn_speed_radians,
'hover_speed_threshold': self.hover_speed_threshold,
'ignore_all_but_player': self.ignore_all_but_player,
'ignore_all_during_death': self.ignore_all_during_death,
'suicide_on_player_touch': self.suicide_on_player_touch,
'disable_collision_time_after_creation': self.disable_collision_time_after_creation,
'life_time': self.life_time,
'max_distance_from_origin_squared': self.max_distance_from_origin_squared,
'targeting_time': self.targeting_time,
'telegraph_time': self.telegraph_time,
'pause_time': self.pause_time,
'stop_distance_squared': self.stop_distance_squared,
'stop_speed': self.stop_speed,
'flight_sound': self.flight_sound,
'flight_sound_low_pass_filter': self.flight_sound_low_pass_filter.to_json(),
'flight_sound_pitch': self.flight_sound_pitch.to_json(),
'flight_sound_volume': self.flight_sound_volume.to_json(),
'maximum_speed_for_audio_inverse': self.maximum_speed_for_audio_inverse,
'flight_sound_deceleration_k': self.flight_sound_deceleration_k,
}
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_seek_when_behavior_inactive(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_attack_range_squared(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_speed_radians(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hover_speed_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ignore_all_but_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_all_during_death(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_suicide_on_player_touch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_collision_time_after_creation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_distance_from_origin_squared(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_targeting_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_telegraph_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pause_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stop_distance_squared(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stop_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_flight_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_flight_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_maximum_speed_for_audio_inverse(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_sound_deceleration_k(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb8f60f9a: ('mode', _decode_mode),
0x745a8f03: ('seek_when_behavior_inactive', _decode_seek_when_behavior_inactive),
0xde5bfc61: ('attack_range_squared', _decode_attack_range_squared),
0x6392404e: ('speed', _decode_speed),
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0x589a76ff: ('turn_speed_radians', _decode_turn_speed_radians),
0x332b5518: ('hover_speed_threshold', _decode_hover_speed_threshold),
0xab0f5158: ('ignore_all_but_player', _decode_ignore_all_but_player),
0x884973d2: ('ignore_all_during_death', _decode_ignore_all_during_death),
0xbac80e1f: ('suicide_on_player_touch', _decode_suicide_on_player_touch),
0xbec99005: ('disable_collision_time_after_creation', _decode_disable_collision_time_after_creation),
0xb02de555: ('life_time', _decode_life_time),
0x928580f: ('max_distance_from_origin_squared', _decode_max_distance_from_origin_squared),
0xd94c3954: ('targeting_time', _decode_targeting_time),
0x8e6bbef1: ('telegraph_time', _decode_telegraph_time),
0x6b08f2f2: ('pause_time', _decode_pause_time),
0x48b45911: ('stop_distance_squared', _decode_stop_distance_squared),
0xd4600821: ('stop_speed', _decode_stop_speed),
0xe1e66b24: ('flight_sound', _decode_flight_sound),
0xb413c45f: ('flight_sound_low_pass_filter', _decode_flight_sound_low_pass_filter),
0x76c7464c: ('flight_sound_pitch', _decode_flight_sound_pitch),
0x10e05aaf: ('flight_sound_volume', _decode_flight_sound_volume),
0xbda0b3f2: ('maximum_speed_for_audio_inverse', _decode_maximum_speed_for_audio_inverse),
0x7a7df6e3: ('flight_sound_deceleration_k', _decode_flight_sound_deceleration_k),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SeekerBehaviorData.py | 0.676086 | 0.287443 | SeekerBehaviorData.py | 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.Transform import Transform
@dataclasses.dataclass()
class EditorProperties(BaseProperty):
name: str = dataclasses.field(default='')
transform: Transform = dataclasses.field(default_factory=Transform)
active: bool = dataclasses.field(default=True)
unknown: int = dataclasses.field(default=3)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'INAM') # 0x494e414d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.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'XFRM') # 0x5846524d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.transform.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'ACTV') # 0x41435456
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'])\x8aC') # 0x5d298a43
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
name=data['name'],
transform=Transform.from_json(data['transform']),
active=data['active'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'name': self.name,
'transform': self.transform.to_json(),
'active': self.active,
'unknown': self.unknown,
}
def _decode_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_transform(data: typing.BinaryIO, property_size: int):
return Transform.from_stream(data, property_size)
def _decode_active(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('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x494e414d: ('name', _decode_name),
0x5846524d: ('transform', _decode_transform),
0x41435456: ('active', _decode_active),
0x5d298a43: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/EditorProperties.py | 0.606382 | 0.348895 | EditorProperties.py | 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 UnknownStruct249(BaseProperty):
music_fade: bool = dataclasses.field(default=True)
music_fade_out_time: float = dataclasses.field(default=0.5)
play_jingle: bool = dataclasses.field(default=True)
camera_fade: bool = dataclasses.field(default=True)
camera_fade_out_delay_time: float = dataclasses.field(default=1.0)
camera_fade_out_time: float = dataclasses.field(default=1.5)
interface_delay_time: float = dataclasses.field(default=0.5)
volume_fade_out_time: float = dataclasses.field(default=0.75)
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\t') # 9 properties
data.write(b'\xed^\xc8\xa1') # 0xed5ec8a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.music_fade))
data.write(b'\x8d\xce\xa3O') # 0x8dcea34f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.music_fade_out_time))
data.write(b'\x03\x97\xdc\xf7') # 0x397dcf7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.play_jingle))
data.write(b'\x9ab\x10\xd3') # 0x9a6210d3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.camera_fade))
data.write(b'tf\xf0H') # 0x7466f048
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_fade_out_delay_time))
data.write(b'\xc3\xdd\x83\x89') # 0xc3dd8389
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_fade_out_time))
data.write(b'tj\x13\xe9') # 0x746a13e9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interface_delay_time))
data.write(b'/\x9d\xedK') # 0x2f9ded4b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_fade_out_time))
data.write(b'+\xd2\xae2') # 0x2bd2ae32
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(
music_fade=data['music_fade'],
music_fade_out_time=data['music_fade_out_time'],
play_jingle=data['play_jingle'],
camera_fade=data['camera_fade'],
camera_fade_out_delay_time=data['camera_fade_out_delay_time'],
camera_fade_out_time=data['camera_fade_out_time'],
interface_delay_time=data['interface_delay_time'],
volume_fade_out_time=data['volume_fade_out_time'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'music_fade': self.music_fade,
'music_fade_out_time': self.music_fade_out_time,
'play_jingle': self.play_jingle,
'camera_fade': self.camera_fade,
'camera_fade_out_delay_time': self.camera_fade_out_delay_time,
'camera_fade_out_time': self.camera_fade_out_time,
'interface_delay_time': self.interface_delay_time,
'volume_fade_out_time': self.volume_fade_out_time,
'unknown': self.unknown,
}
def _decode_music_fade(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_music_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_play_jingle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_camera_fade(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_camera_fade_out_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_interface_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume_fade_out_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]]] = {
0xed5ec8a1: ('music_fade', _decode_music_fade),
0x8dcea34f: ('music_fade_out_time', _decode_music_fade_out_time),
0x397dcf7: ('play_jingle', _decode_play_jingle),
0x9a6210d3: ('camera_fade', _decode_camera_fade),
0x7466f048: ('camera_fade_out_delay_time', _decode_camera_fade_out_delay_time),
0xc3dd8389: ('camera_fade_out_time', _decode_camera_fade_out_time),
0x746a13e9: ('interface_delay_time', _decode_interface_delay_time),
0x2f9ded4b: ('volume_fade_out_time', _decode_volume_fade_out_time),
0x2bd2ae32: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct249.py | 0.650023 | 0.263061 | UnknownStruct249.py | 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.PlayerMountRiderData import PlayerMountRiderData
@dataclasses.dataclass()
class PlayerMountRiderList(BaseProperty):
max_riders: int = dataclasses.field(default=0)
rider1: PlayerMountRiderData = dataclasses.field(default_factory=PlayerMountRiderData)
rider2: PlayerMountRiderData = dataclasses.field(default_factory=PlayerMountRiderData)
rider3: PlayerMountRiderData = dataclasses.field(default_factory=PlayerMountRiderData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xfbj\x98\x1b') # 0xfb6a981b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_riders))
data.write(b'9\x82\xde\xc6') # 0x3982dec6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rider1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'B\x9c\\%') # 0x429c5c25
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rider2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xddF\xdf\xbb') # 0xdd46dfbb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rider3.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_riders=data['max_riders'],
rider1=PlayerMountRiderData.from_json(data['rider1']),
rider2=PlayerMountRiderData.from_json(data['rider2']),
rider3=PlayerMountRiderData.from_json(data['rider3']),
)
def to_json(self) -> dict:
return {
'max_riders': self.max_riders,
'rider1': self.rider1.to_json(),
'rider2': self.rider2.to_json(),
'rider3': self.rider3.to_json(),
}
def _decode_max_riders(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_rider1(data: typing.BinaryIO, property_size: int):
return PlayerMountRiderData.from_stream(data, property_size)
def _decode_rider2(data: typing.BinaryIO, property_size: int):
return PlayerMountRiderData.from_stream(data, property_size)
def _decode_rider3(data: typing.BinaryIO, property_size: int):
return PlayerMountRiderData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfb6a981b: ('max_riders', _decode_max_riders),
0x3982dec6: ('rider1', _decode_rider1),
0x429c5c25: ('rider2', _decode_rider2),
0xdd46dfbb: ('rider3', _decode_rider3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMountRiderList.py | 0.637482 | 0.368747 | PlayerMountRiderList.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class PlayerAlternateSkin(BaseProperty):
texture_set: int = dataclasses.field(default=0)
alternate: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
tar: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
super_guide: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
super_guide_alternate: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
invulnerable: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
invulnerable_alternate: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'k@\xac\xef') # 0x6b40acef
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.texture_set))
data.write(b'/\xae\x04z') # 0x2fae047a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.alternate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\xcf\x02:') # 0x21cf023a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tar.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'G\xebZh') # 0x47eb5a68
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.super_guide.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\t)\xf0') # 0xfc0929f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.super_guide_alternate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'5\x9b\x85\x13') # 0x359b8513
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.invulnerable.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfb@l\xa9') # 0xfb406ca9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.invulnerable_alternate.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_set=data['texture_set'],
alternate=AnimationParameters.from_json(data['alternate']),
tar=AnimationParameters.from_json(data['tar']),
super_guide=AnimationParameters.from_json(data['super_guide']),
super_guide_alternate=AnimationParameters.from_json(data['super_guide_alternate']),
invulnerable=AnimationParameters.from_json(data['invulnerable']),
invulnerable_alternate=AnimationParameters.from_json(data['invulnerable_alternate']),
)
def to_json(self) -> dict:
return {
'texture_set': self.texture_set,
'alternate': self.alternate.to_json(),
'tar': self.tar.to_json(),
'super_guide': self.super_guide.to_json(),
'super_guide_alternate': self.super_guide_alternate.to_json(),
'invulnerable': self.invulnerable.to_json(),
'invulnerable_alternate': self.invulnerable_alternate.to_json(),
}
def _decode_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_alternate(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_tar(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_super_guide(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_super_guide_alternate(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_invulnerable(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_invulnerable_alternate(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]]] = {
0x6b40acef: ('texture_set', _decode_texture_set),
0x2fae047a: ('alternate', _decode_alternate),
0x21cf023a: ('tar', _decode_tar),
0x47eb5a68: ('super_guide', _decode_super_guide),
0xfc0929f0: ('super_guide_alternate', _decode_super_guide_alternate),
0x359b8513: ('invulnerable', _decode_invulnerable),
0xfb406ca9: ('invulnerable_alternate', _decode_invulnerable_alternate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerAlternateSkin.py | 0.662796 | 0.298901 | PlayerAlternateSkin.py | 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.DKBarrelGlueData import DKBarrelGlueData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct138 import UnknownStruct138
@dataclasses.dataclass()
class CharacterGlueData(BaseProperty):
glue_type: enums.GlueType = dataclasses.field(default=enums.GlueType.Unknown1)
unknown_struct138: UnknownStruct138 = dataclasses.field(default_factory=UnknownStruct138)
dk_barrel_glue_data: DKBarrelGlueData = dataclasses.field(default_factory=DKBarrelGlueData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'A\x1d\x05R') # 0x411d0552
data.write(b'\x00\x04') # size
self.glue_type.to_stream(data)
data.write(b'\xa4osA') # 0xa46f7341
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct138.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6S\x80e') # 0x36538065
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dk_barrel_glue_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(
glue_type=enums.GlueType.from_json(data['glue_type']),
unknown_struct138=UnknownStruct138.from_json(data['unknown_struct138']),
dk_barrel_glue_data=DKBarrelGlueData.from_json(data['dk_barrel_glue_data']),
)
def to_json(self) -> dict:
return {
'glue_type': self.glue_type.to_json(),
'unknown_struct138': self.unknown_struct138.to_json(),
'dk_barrel_glue_data': self.dk_barrel_glue_data.to_json(),
}
def _decode_glue_type(data: typing.BinaryIO, property_size: int):
return enums.GlueType.from_stream(data)
def _decode_unknown_struct138(data: typing.BinaryIO, property_size: int):
return UnknownStruct138.from_stream(data, property_size)
def _decode_dk_barrel_glue_data(data: typing.BinaryIO, property_size: int):
return DKBarrelGlueData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x411d0552: ('glue_type', _decode_glue_type),
0xa46f7341: ('unknown_struct138', _decode_unknown_struct138),
0x36538065: ('dk_barrel_glue_data', _decode_dk_barrel_glue_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CharacterGlueData.py | 0.610453 | 0.271074 | CharacterGlueData.py | 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.SeparateAndReformParts import SeparateAndReformParts
@dataclasses.dataclass()
class SeparateAndReformBehaviorData(BaseProperty):
number_of_parts: int = dataclasses.field(default=10)
player_relative: bool = dataclasses.field(default=False)
do_not_wait_for_reform: bool = dataclasses.field(default=True)
part1: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part2: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part3: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part4: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part5: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part6: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part7: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part8: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part9: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
part10: SeparateAndReformParts = dataclasses.field(default_factory=SeparateAndReformParts)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\x8bYF\x11') # 0x8b594611
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_parts))
data.write(b'`\xbe<\x08') # 0x60be3c08
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.player_relative))
data.write(b'`\xf7\xe8?') # 0x60f7e83f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.do_not_wait_for_reform))
data.write(b'6\xa0T\xc3') # 0x36a054c3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part1.to_stream(data, default_override={'offset': -2.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@Em\xfe') # 0x40456dfe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part2.to_stream(data, default_override={'offset': -4.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdb6\x87*') # 0xdb36872a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part3.to_stream(data, default_override={'offset': -6.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xad\x8f\x1f\x84') # 0xad8f1f84
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part4.to_stream(data, default_override={'offset': -8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xfc\xf5P') # 0x36fcf550
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part5.to_stream(data, default_override={'offset': -10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@\x19\xccm') # 0x4019cc6d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part6.to_stream(data, default_override={'offset': 2.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdbj&\xb9') # 0xdb6a26b9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part7.to_stream(data, default_override={'offset': 4.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xadj\xfd1') # 0xad6afd31
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part8.to_stream(data, default_override={'offset': 6.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\x19\x17\xe5') # 0x361917e5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part9.to_stream(data, default_override={'offset': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'0\xc90\x88') # 0x30c93088
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.part10.to_stream(data, default_override={'offset': 10.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(
number_of_parts=data['number_of_parts'],
player_relative=data['player_relative'],
do_not_wait_for_reform=data['do_not_wait_for_reform'],
part1=SeparateAndReformParts.from_json(data['part1']),
part2=SeparateAndReformParts.from_json(data['part2']),
part3=SeparateAndReformParts.from_json(data['part3']),
part4=SeparateAndReformParts.from_json(data['part4']),
part5=SeparateAndReformParts.from_json(data['part5']),
part6=SeparateAndReformParts.from_json(data['part6']),
part7=SeparateAndReformParts.from_json(data['part7']),
part8=SeparateAndReformParts.from_json(data['part8']),
part9=SeparateAndReformParts.from_json(data['part9']),
part10=SeparateAndReformParts.from_json(data['part10']),
)
def to_json(self) -> dict:
return {
'number_of_parts': self.number_of_parts,
'player_relative': self.player_relative,
'do_not_wait_for_reform': self.do_not_wait_for_reform,
'part1': self.part1.to_json(),
'part2': self.part2.to_json(),
'part3': self.part3.to_json(),
'part4': self.part4.to_json(),
'part5': self.part5.to_json(),
'part6': self.part6.to_json(),
'part7': self.part7.to_json(),
'part8': self.part8.to_json(),
'part9': self.part9.to_json(),
'part10': self.part10.to_json(),
}
def _decode_number_of_parts(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_player_relative(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_do_not_wait_for_reform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_part1(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': -2.0})
def _decode_part2(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': -4.0})
def _decode_part3(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': -6.0})
def _decode_part4(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': -8.0})
def _decode_part5(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': -10.0})
def _decode_part6(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': 2.0})
def _decode_part7(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': 4.0})
def _decode_part8(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': 6.0})
def _decode_part9(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': 8.0})
def _decode_part10(data: typing.BinaryIO, property_size: int):
return SeparateAndReformParts.from_stream(data, property_size, default_override={'offset': 10.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8b594611: ('number_of_parts', _decode_number_of_parts),
0x60be3c08: ('player_relative', _decode_player_relative),
0x60f7e83f: ('do_not_wait_for_reform', _decode_do_not_wait_for_reform),
0x36a054c3: ('part1', _decode_part1),
0x40456dfe: ('part2', _decode_part2),
0xdb36872a: ('part3', _decode_part3),
0xad8f1f84: ('part4', _decode_part4),
0x36fcf550: ('part5', _decode_part5),
0x4019cc6d: ('part6', _decode_part6),
0xdb6a26b9: ('part7', _decode_part7),
0xad6afd31: ('part8', _decode_part8),
0x361917e5: ('part9', _decode_part9),
0x30c93088: ('part10', _decode_part10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SeparateAndReformBehaviorData.py | 0.484136 | 0.247078 | SeparateAndReformBehaviorData.py | 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 UnknownStruct183(BaseProperty):
status_empty: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x4cb7e35d: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
status_puzzle: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x71280e23: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
status_mirror: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
status_invisible: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'G+\xf3_') # 0x472bf35f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.status_empty))
data.write(b'L\xb7\xe3]') # 0x4cb7e35d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x4cb7e35d))
data.write(b'8\xa2*\xc5') # 0x38a22ac5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.status_puzzle))
data.write(b'q(\x0e#') # 0x71280e23
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x71280e23))
data.write(b"'TS|") # 0x2754537c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.status_mirror))
data.write(b'\xe2\xe6.\xe5') # 0xe2e62ee5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.status_invisible))
@classmethod
def from_json(cls, data: dict):
return cls(
status_empty=data['status_empty'],
strg_0x4cb7e35d=data['strg_0x4cb7e35d'],
status_puzzle=data['status_puzzle'],
strg_0x71280e23=data['strg_0x71280e23'],
status_mirror=data['status_mirror'],
status_invisible=data['status_invisible'],
)
def to_json(self) -> dict:
return {
'status_empty': self.status_empty,
'strg_0x4cb7e35d': self.strg_0x4cb7e35d,
'status_puzzle': self.status_puzzle,
'strg_0x71280e23': self.strg_0x71280e23,
'status_mirror': self.status_mirror,
'status_invisible': self.status_invisible,
}
_FAST_FORMAT = None
_FAST_IDS = (0x472bf35f, 0x4cb7e35d, 0x38a22ac5, 0x71280e23, 0x2754537c, 0xe2e62ee5)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct183]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(84))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct183(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_status_empty(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x4cb7e35d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_status_puzzle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x71280e23(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_status_mirror(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_status_invisible(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]]] = {
0x472bf35f: ('status_empty', _decode_status_empty),
0x4cb7e35d: ('strg_0x4cb7e35d', _decode_strg_0x4cb7e35d),
0x38a22ac5: ('status_puzzle', _decode_status_puzzle),
0x71280e23: ('strg_0x71280e23', _decode_strg_0x71280e23),
0x2754537c: ('status_mirror', _decode_status_mirror),
0xe2e62ee5: ('status_invisible', _decode_status_invisible),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct183.py | 0.571647 | 0.251326 | UnknownStruct183.py | 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 RevolutionPhysicalControl(BaseProperty):
physical_control: enums.PhysicalControl = dataclasses.field(default=enums.PhysicalControl.Unknown1)
control_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'`\xd6bD') # 0x60d66244
data.write(b'\x00\x04') # size
self.physical_control.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)
@classmethod
def from_json(cls, data: dict):
return cls(
physical_control=enums.PhysicalControl.from_json(data['physical_control']),
control_spline=Spline.from_json(data['control_spline']),
)
def to_json(self) -> dict:
return {
'physical_control': self.physical_control.to_json(),
'control_spline': self.control_spline.to_json(),
}
def _decode_physical_control(data: typing.BinaryIO, property_size: int):
return enums.PhysicalControl.from_stream(data)
def _decode_control_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]]] = {
0x60d66244: ('physical_control', _decode_physical_control),
0x15567fe7: ('control_spline', _decode_control_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RevolutionPhysicalControl.py | 0.647018 | 0.256931 | RevolutionPhysicalControl.py | 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 SurfaceOrientation(BaseProperty):
flags_surface_orientation: int = dataclasses.field(default=256)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\x10\xe6\xf3f') # 0x10e6f366
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_surface_orientation))
@classmethod
def from_json(cls, data: dict):
return cls(
flags_surface_orientation=data['flags_surface_orientation'],
)
def to_json(self) -> dict:
return {
'flags_surface_orientation': self.flags_surface_orientation,
}
_FAST_FORMAT = None
_FAST_IDS = (0x10e6f366)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SurfaceOrientation]:
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 SurfaceOrientation(
dec[2],
)
def _decode_flags_surface_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x10e6f366: ('flags_surface_orientation', _decode_flags_surface_orientation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SurfaceOrientation.py | 0.68784 | 0.314011 | SurfaceOrientation.py | 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 DamageVulnerability(BaseProperty):
unknown_0xad373af2: float = dataclasses.field(default=2.0)
unknown_0x6bec3998: float = dataclasses.field(default=0.0)
unknown_0x44337a05: float = dataclasses.field(default=0.0)
unknown_0x10f37815: int = dataclasses.field(default=524288)
unknown_0xf65feef8: int = dataclasses.field(default=524288)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xad7:\xf2') # 0xad373af2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xad373af2))
data.write(b'k\xec9\x98') # 0x6bec3998
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6bec3998))
data.write(b'D3z\x05') # 0x44337a05
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x44337a05))
data.write(b'\x10\xf3x\x15') # 0x10f37815
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x10f37815))
data.write(b'\xf6_\xee\xf8') # 0xf65feef8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xf65feef8))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xad373af2=data['unknown_0xad373af2'],
unknown_0x6bec3998=data['unknown_0x6bec3998'],
unknown_0x44337a05=data['unknown_0x44337a05'],
unknown_0x10f37815=data['unknown_0x10f37815'],
unknown_0xf65feef8=data['unknown_0xf65feef8'],
)
def to_json(self) -> dict:
return {
'unknown_0xad373af2': self.unknown_0xad373af2,
'unknown_0x6bec3998': self.unknown_0x6bec3998,
'unknown_0x44337a05': self.unknown_0x44337a05,
'unknown_0x10f37815': self.unknown_0x10f37815,
'unknown_0xf65feef8': self.unknown_0xf65feef8,
}
_FAST_FORMAT = None
_FAST_IDS = (0xad373af2, 0x6bec3998, 0x44337a05, 0x10f37815, 0xf65feef8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DamageVulnerability]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHlLHl')
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 DamageVulnerability(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_unknown_0xad373af2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6bec3998(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x44337a05(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x10f37815(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xf65feef8(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]]] = {
0xad373af2: ('unknown_0xad373af2', _decode_unknown_0xad373af2),
0x6bec3998: ('unknown_0x6bec3998', _decode_unknown_0x6bec3998),
0x44337a05: ('unknown_0x44337a05', _decode_unknown_0x44337a05),
0x10f37815: ('unknown_0x10f37815', _decode_unknown_0x10f37815),
0xf65feef8: ('unknown_0xf65feef8', _decode_unknown_0xf65feef8),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DamageVulnerability.py | 0.597608 | 0.278164 | DamageVulnerability.py | 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.MoleTrainManagerStructB import MoleTrainManagerStructB
@dataclasses.dataclass()
class UnknownStruct238(BaseProperty):
unknown_0x5d57fc7c: float = dataclasses.field(default=1.0)
unknown_0xe205412c: float = dataclasses.field(default=0.5)
cart_speed: float = dataclasses.field(default=10.0)
unknown_0x2d3c5998: float = dataclasses.field(default=2.5)
sequence_count: int = dataclasses.field(default=1)
mole_train_manager_struct_b_0x9aecdc44: MoleTrainManagerStructB = dataclasses.field(default_factory=MoleTrainManagerStructB)
mole_train_manager_struct_b_0x2978f187: MoleTrainManagerStructB = dataclasses.field(default_factory=MoleTrainManagerStructB)
mole_train_manager_struct_b_0x47f4eac6: MoleTrainManagerStructB = dataclasses.field(default_factory=MoleTrainManagerStructB)
mole_train_manager_struct_b_0x9521ac40: MoleTrainManagerStructB = dataclasses.field(default_factory=MoleTrainManagerStructB)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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']W\xfc|') # 0x5d57fc7c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5d57fc7c))
data.write(b'\xe2\x05A,') # 0xe205412c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe205412c))
data.write(b'9\x94\xbe\x14') # 0x3994be14
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cart_speed))
data.write(b'-<Y\x98') # 0x2d3c5998
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2d3c5998))
data.write(b'e\xec\xebz') # 0x65eceb7a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sequence_count))
data.write(b'\x9a\xec\xdcD') # 0x9aecdc44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_b_0x9aecdc44.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b')x\xf1\x87') # 0x2978f187
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_b_0x2978f187.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'G\xf4\xea\xc6') # 0x47f4eac6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_b_0x47f4eac6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95!\xac@') # 0x9521ac40
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mole_train_manager_struct_b_0x9521ac40.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_0x5d57fc7c=data['unknown_0x5d57fc7c'],
unknown_0xe205412c=data['unknown_0xe205412c'],
cart_speed=data['cart_speed'],
unknown_0x2d3c5998=data['unknown_0x2d3c5998'],
sequence_count=data['sequence_count'],
mole_train_manager_struct_b_0x9aecdc44=MoleTrainManagerStructB.from_json(data['mole_train_manager_struct_b_0x9aecdc44']),
mole_train_manager_struct_b_0x2978f187=MoleTrainManagerStructB.from_json(data['mole_train_manager_struct_b_0x2978f187']),
mole_train_manager_struct_b_0x47f4eac6=MoleTrainManagerStructB.from_json(data['mole_train_manager_struct_b_0x47f4eac6']),
mole_train_manager_struct_b_0x9521ac40=MoleTrainManagerStructB.from_json(data['mole_train_manager_struct_b_0x9521ac40']),
)
def to_json(self) -> dict:
return {
'unknown_0x5d57fc7c': self.unknown_0x5d57fc7c,
'unknown_0xe205412c': self.unknown_0xe205412c,
'cart_speed': self.cart_speed,
'unknown_0x2d3c5998': self.unknown_0x2d3c5998,
'sequence_count': self.sequence_count,
'mole_train_manager_struct_b_0x9aecdc44': self.mole_train_manager_struct_b_0x9aecdc44.to_json(),
'mole_train_manager_struct_b_0x2978f187': self.mole_train_manager_struct_b_0x2978f187.to_json(),
'mole_train_manager_struct_b_0x47f4eac6': self.mole_train_manager_struct_b_0x47f4eac6.to_json(),
'mole_train_manager_struct_b_0x9521ac40': self.mole_train_manager_struct_b_0x9521ac40.to_json(),
}
def _decode_unknown_0x5d57fc7c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe205412c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cart_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2d3c5998(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sequence_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mole_train_manager_struct_b_0x9aecdc44(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructB.from_stream(data, property_size)
def _decode_mole_train_manager_struct_b_0x2978f187(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructB.from_stream(data, property_size)
def _decode_mole_train_manager_struct_b_0x47f4eac6(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructB.from_stream(data, property_size)
def _decode_mole_train_manager_struct_b_0x9521ac40(data: typing.BinaryIO, property_size: int):
return MoleTrainManagerStructB.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5d57fc7c: ('unknown_0x5d57fc7c', _decode_unknown_0x5d57fc7c),
0xe205412c: ('unknown_0xe205412c', _decode_unknown_0xe205412c),
0x3994be14: ('cart_speed', _decode_cart_speed),
0x2d3c5998: ('unknown_0x2d3c5998', _decode_unknown_0x2d3c5998),
0x65eceb7a: ('sequence_count', _decode_sequence_count),
0x9aecdc44: ('mole_train_manager_struct_b_0x9aecdc44', _decode_mole_train_manager_struct_b_0x9aecdc44),
0x2978f187: ('mole_train_manager_struct_b_0x2978f187', _decode_mole_train_manager_struct_b_0x2978f187),
0x47f4eac6: ('mole_train_manager_struct_b_0x47f4eac6', _decode_mole_train_manager_struct_b_0x47f4eac6),
0x9521ac40: ('mole_train_manager_struct_b_0x9521ac40', _decode_mole_train_manager_struct_b_0x9521ac40),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct238.py | 0.552419 | 0.320157 | UnknownStruct238.py | 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 UnknownStruct66(BaseProperty):
unknown: bool = dataclasses.field(default=False)
debug_name: str = dataclasses.field(default='')
max_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\x03') # 3 properties
data.write(b'\x18\xc79j') # 0x18c7396a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\xbd\x0b~\xde') # 0xbd0b7ede
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.debug_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'l\x84\xc5\x88') # 0x6c84c588
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_value))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
debug_name=data['debug_name'],
max_value=data['max_value'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'debug_name': self.debug_name,
'max_value': self.max_value,
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_debug_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_max_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]]] = {
0x18c7396a: ('unknown', _decode_unknown),
0xbd0b7ede: ('debug_name', _decode_debug_name),
0x6c84c588: ('max_value', _decode_max_value),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct66.py | 0.575469 | 0.309715 | UnknownStruct66.py | 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.Vector import Vector
@dataclasses.dataclass()
class ProjectileBounceData(BaseProperty):
unknown_0x96b863c5: int = dataclasses.field(default=1)
bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x76c79503: float = dataclasses.field(default=1.0)
bounce_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x8ec68a96: bool = dataclasses.field(default=False)
unknown_0xec56e80d: float = dataclasses.field(default=1.0)
unknown_0x8e55276e: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'\x96\xb8c\xc5') # 0x96b863c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x96b863c5))
data.write(b'\xf1\x92Uv') # 0xf1925576
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_sound))
data.write(b'v\xc7\x95\x03') # 0x76c79503
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76c79503))
data.write(b'!|7\xc2') # 0x217c37c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bounce_particle_effect))
data.write(b'\x8e\xc6\x8a\x96') # 0x8ec68a96
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8ec68a96))
data.write(b'\xecV\xe8\r') # 0xec56e80d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xec56e80d))
data.write(b"\x8eU'n") # 0x8e55276e
data.write(b'\x00\x0c') # size
self.unknown_0x8e55276e.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x96b863c5=data['unknown_0x96b863c5'],
bounce_sound=data['bounce_sound'],
unknown_0x76c79503=data['unknown_0x76c79503'],
bounce_particle_effect=data['bounce_particle_effect'],
unknown_0x8ec68a96=data['unknown_0x8ec68a96'],
unknown_0xec56e80d=data['unknown_0xec56e80d'],
unknown_0x8e55276e=Vector.from_json(data['unknown_0x8e55276e']),
)
def to_json(self) -> dict:
return {
'unknown_0x96b863c5': self.unknown_0x96b863c5,
'bounce_sound': self.bounce_sound,
'unknown_0x76c79503': self.unknown_0x76c79503,
'bounce_particle_effect': self.bounce_particle_effect,
'unknown_0x8ec68a96': self.unknown_0x8ec68a96,
'unknown_0xec56e80d': self.unknown_0xec56e80d,
'unknown_0x8e55276e': self.unknown_0x8e55276e.to_json(),
}
def _decode_unknown_0x96b863c5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x76c79503(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x8ec68a96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xec56e80d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8e55276e(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x96b863c5: ('unknown_0x96b863c5', _decode_unknown_0x96b863c5),
0xf1925576: ('bounce_sound', _decode_bounce_sound),
0x76c79503: ('unknown_0x76c79503', _decode_unknown_0x76c79503),
0x217c37c2: ('bounce_particle_effect', _decode_bounce_particle_effect),
0x8ec68a96: ('unknown_0x8ec68a96', _decode_unknown_0x8ec68a96),
0xec56e80d: ('unknown_0xec56e80d', _decode_unknown_0xec56e80d),
0x8e55276e: ('unknown_0x8e55276e', _decode_unknown_0x8e55276e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileBounceData.py | 0.677367 | 0.257788 | ProjectileBounceData.py | 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.UnknownStruct28 import UnknownStruct28
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct146(BaseProperty):
unknown_struct28: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
horizontal_instructions: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
title_string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'\xc6\x8b\xc9\xec') # 0xc68bc9ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf2\x00\x912') # 0xf2009132
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.horizontal_instructions))
data.write(b'\x00\xcest') # 0xce7374
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'\xc7\xb1\x83\xb7') # 0xc7b183b7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title_string_table))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct28=UnknownStruct28.from_json(data['unknown_struct28']),
horizontal_instructions=data['horizontal_instructions'],
strg=data['strg'],
title_string_table=data['title_string_table'],
)
def to_json(self) -> dict:
return {
'unknown_struct28': self.unknown_struct28.to_json(),
'horizontal_instructions': self.horizontal_instructions,
'strg': self.strg,
'title_string_table': self.title_string_table,
}
def _decode_unknown_struct28(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_horizontal_instructions(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_title_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xc68bc9ec: ('unknown_struct28', _decode_unknown_struct28),
0xf2009132: ('horizontal_instructions', _decode_horizontal_instructions),
0xce7374: ('strg', _decode_strg),
0xc7b183b7: ('title_string_table', _decode_title_string_table),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct146.py | 0.594551 | 0.235207 | UnknownStruct146.py | 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 UnknownStruct185(BaseProperty):
caud_0xa28b199d: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x003e7991: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
walking_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
arrival_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
enter_area_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
exit_area_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
highlight_area_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\x07') # 7 properties
data.write(b'\xa2\x8b\x19\x9d') # 0xa28b199d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0xa28b199d))
data.write(b'\x00>y\x91') # 0x3e7991
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x003e7991))
data.write(b'\x87P\x1d1') # 0x87501d31
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.walking_sound))
data.write(b'rg\x91e') # 0x72679165
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.arrival_sound))
data.write(b'\xccp\xe9\x1c') # 0xcc70e91c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.enter_area_sound))
data.write(b'\xb2\xb0*\x99') # 0xb2b02a99
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.exit_area_sound))
data.write(b'C\x92\xd0\xc4') # 0x4392d0c4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.highlight_area_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
caud_0xa28b199d=data['caud_0xa28b199d'],
caud_0x003e7991=data['caud_0x003e7991'],
walking_sound=data['walking_sound'],
arrival_sound=data['arrival_sound'],
enter_area_sound=data['enter_area_sound'],
exit_area_sound=data['exit_area_sound'],
highlight_area_sound=data['highlight_area_sound'],
)
def to_json(self) -> dict:
return {
'caud_0xa28b199d': self.caud_0xa28b199d,
'caud_0x003e7991': self.caud_0x003e7991,
'walking_sound': self.walking_sound,
'arrival_sound': self.arrival_sound,
'enter_area_sound': self.enter_area_sound,
'exit_area_sound': self.exit_area_sound,
'highlight_area_sound': self.highlight_area_sound,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa28b199d, 0x3e7991, 0x87501d31, 0x72679165, 0xcc70e91c, 0xb2b02a99, 0x4392d0c4)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct185]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHQLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(98))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct185(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_caud_0xa28b199d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x003e7991(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_walking_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_arrival_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_enter_area_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_exit_area_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_highlight_area_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]]] = {
0xa28b199d: ('caud_0xa28b199d', _decode_caud_0xa28b199d),
0x3e7991: ('caud_0x003e7991', _decode_caud_0x003e7991),
0x87501d31: ('walking_sound', _decode_walking_sound),
0x72679165: ('arrival_sound', _decode_arrival_sound),
0xcc70e91c: ('enter_area_sound', _decode_enter_area_sound),
0xb2b02a99: ('exit_area_sound', _decode_exit_area_sound),
0x4392d0c4: ('highlight_area_sound', _decode_highlight_area_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct185.py | 0.469277 | 0.204074 | UnknownStruct185.py | 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 UnknownStruct59(BaseProperty):
unknown_0xf228ec53: float = dataclasses.field(default=3.0)
unknown_0xd91227f1: float = dataclasses.field(default=7.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'\xf2(\xecS') # 0xf228ec53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf228ec53))
data.write(b"\xd9\x12'\xf1") # 0xd91227f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd91227f1))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xf228ec53=data['unknown_0xf228ec53'],
unknown_0xd91227f1=data['unknown_0xd91227f1'],
)
def to_json(self) -> dict:
return {
'unknown_0xf228ec53': self.unknown_0xf228ec53,
'unknown_0xd91227f1': self.unknown_0xd91227f1,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf228ec53, 0xd91227f1)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct59]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct59(
dec[2],
dec[5],
)
def _decode_unknown_0xf228ec53(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd91227f1(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]]] = {
0xf228ec53: ('unknown_0xf228ec53', _decode_unknown_0xf228ec53),
0xd91227f1: ('unknown_0xd91227f1', _decode_unknown_0xd91227f1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct59.py | 0.622574 | 0.274309 | UnknownStruct59.py | 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
@dataclasses.dataclass()
class PlayerOffscreenIndicatorIconData(BaseProperty):
indicator_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
blend_mode: enums.BlendMode = dataclasses.field(default=enums.BlendMode.Unknown1)
override_width: int = dataclasses.field(default=0)
override_height: 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\x04') # 4 properties
data.write(b'5\xa9=\xd5') # 0x35a93dd5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.indicator_texture))
data.write(b'\xcd\x0bM\t') # 0xcd0b4d09
data.write(b'\x00\x04') # size
self.blend_mode.to_stream(data)
data.write(b'\xa3\xc8\xf0m') # 0xa3c8f06d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.override_width))
data.write(b'\xb3\x9a\x8a6') # 0xb39a8a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.override_height))
@classmethod
def from_json(cls, data: dict):
return cls(
indicator_texture=data['indicator_texture'],
blend_mode=enums.BlendMode.from_json(data['blend_mode']),
override_width=data['override_width'],
override_height=data['override_height'],
)
def to_json(self) -> dict:
return {
'indicator_texture': self.indicator_texture,
'blend_mode': self.blend_mode.to_json(),
'override_width': self.override_width,
'override_height': self.override_height,
}
_FAST_FORMAT = None
_FAST_IDS = (0x35a93dd5, 0xcd0b4d09, 0xa3c8f06d, 0xb39a8a36)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerOffscreenIndicatorIconData]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHLLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(44))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return PlayerOffscreenIndicatorIconData(
dec[2],
enums.BlendMode(dec[5]),
dec[8],
dec[11],
)
def _decode_indicator_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.BlendMode.from_stream(data)
def _decode_override_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_override_height(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]]] = {
0x35a93dd5: ('indicator_texture', _decode_indicator_texture),
0xcd0b4d09: ('blend_mode', _decode_blend_mode),
0xa3c8f06d: ('override_width', _decode_override_width),
0xb39a8a36: ('override_height', _decode_override_height),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerOffscreenIndicatorIconData.py | 0.620852 | 0.229892 | PlayerOffscreenIndicatorIconData.py | 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.IslandAreaStruct import IslandAreaStruct
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct184(BaseProperty):
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
item_names: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
descriptions: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
confirm: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
entry_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
exit_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
island_area_struct_0x57cb6052: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
island_area_struct_0x4c256cd9: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
island_area_struct_0xfa4dc52c: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
island_area_struct_0x7803ae46: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
island_area_struct_0x2ed30bdd: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
island_area_struct_0xcfbdcf70: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
island_area_struct_0xd611406b: IslandAreaStruct = dataclasses.field(default_factory=IslandAreaStruct)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\x80g\xfeN') # 0x8067fe4e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.item_names))
data.write(b'\xb9\xb1\x8e\xf6') # 0xb9b18ef6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.descriptions))
data.write(b'$\x189\xd4') # 0x241839d4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.confirm))
data.write(b'\xf9R\x9bF') # 0xf9529b46
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.entry_strings))
data.write(b'\x13Y6\r') # 0x1359360d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.exit_strings))
data.write(b'W\xcb`R') # 0x57cb6052
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0x57cb6052.to_stream(data, default_override={'cost': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'L%l\xd9') # 0x4c256cd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0x4c256cd9.to_stream(data, default_override={'cost': 30})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfaM\xc5,') # 0xfa4dc52c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0xfa4dc52c.to_stream(data, default_override={'cost': 10})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\x03\xaeF') # 0x7803ae46
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0x7803ae46.to_stream(data, default_override={'cost': 20})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'.\xd3\x0b\xdd') # 0x2ed30bdd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0x2ed30bdd.to_stream(data, default_override={'cost': 7})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcf\xbd\xcfp') # 0xcfbdcf70
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0xcfbdcf70.to_stream(data, default_override={'cost': 20})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd6\x11@k') # 0xd611406b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_area_struct_0xd611406b.to_stream(data, default_override={'cost': 40})
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(
title=data['title'],
item_names=data['item_names'],
descriptions=data['descriptions'],
confirm=data['confirm'],
entry_strings=data['entry_strings'],
exit_strings=data['exit_strings'],
island_area_struct_0x57cb6052=IslandAreaStruct.from_json(data['island_area_struct_0x57cb6052']),
island_area_struct_0x4c256cd9=IslandAreaStruct.from_json(data['island_area_struct_0x4c256cd9']),
island_area_struct_0xfa4dc52c=IslandAreaStruct.from_json(data['island_area_struct_0xfa4dc52c']),
island_area_struct_0x7803ae46=IslandAreaStruct.from_json(data['island_area_struct_0x7803ae46']),
island_area_struct_0x2ed30bdd=IslandAreaStruct.from_json(data['island_area_struct_0x2ed30bdd']),
island_area_struct_0xcfbdcf70=IslandAreaStruct.from_json(data['island_area_struct_0xcfbdcf70']),
island_area_struct_0xd611406b=IslandAreaStruct.from_json(data['island_area_struct_0xd611406b']),
)
def to_json(self) -> dict:
return {
'title': self.title,
'item_names': self.item_names,
'descriptions': self.descriptions,
'confirm': self.confirm,
'entry_strings': self.entry_strings,
'exit_strings': self.exit_strings,
'island_area_struct_0x57cb6052': self.island_area_struct_0x57cb6052.to_json(),
'island_area_struct_0x4c256cd9': self.island_area_struct_0x4c256cd9.to_json(),
'island_area_struct_0xfa4dc52c': self.island_area_struct_0xfa4dc52c.to_json(),
'island_area_struct_0x7803ae46': self.island_area_struct_0x7803ae46.to_json(),
'island_area_struct_0x2ed30bdd': self.island_area_struct_0x2ed30bdd.to_json(),
'island_area_struct_0xcfbdcf70': self.island_area_struct_0xcfbdcf70.to_json(),
'island_area_struct_0xd611406b': self.island_area_struct_0xd611406b.to_json(),
}
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_item_names(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_descriptions(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_confirm(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_entry_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_exit_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_island_area_struct_0x57cb6052(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 1})
def _decode_island_area_struct_0x4c256cd9(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 30})
def _decode_island_area_struct_0xfa4dc52c(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 10})
def _decode_island_area_struct_0x7803ae46(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 20})
def _decode_island_area_struct_0x2ed30bdd(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 7})
def _decode_island_area_struct_0xcfbdcf70(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 20})
def _decode_island_area_struct_0xd611406b(data: typing.BinaryIO, property_size: int):
return IslandAreaStruct.from_stream(data, property_size, default_override={'cost': 40})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa4f20c17: ('title', _decode_title),
0x8067fe4e: ('item_names', _decode_item_names),
0xb9b18ef6: ('descriptions', _decode_descriptions),
0x241839d4: ('confirm', _decode_confirm),
0xf9529b46: ('entry_strings', _decode_entry_strings),
0x1359360d: ('exit_strings', _decode_exit_strings),
0x57cb6052: ('island_area_struct_0x57cb6052', _decode_island_area_struct_0x57cb6052),
0x4c256cd9: ('island_area_struct_0x4c256cd9', _decode_island_area_struct_0x4c256cd9),
0xfa4dc52c: ('island_area_struct_0xfa4dc52c', _decode_island_area_struct_0xfa4dc52c),
0x7803ae46: ('island_area_struct_0x7803ae46', _decode_island_area_struct_0x7803ae46),
0x2ed30bdd: ('island_area_struct_0x2ed30bdd', _decode_island_area_struct_0x2ed30bdd),
0xcfbdcf70: ('island_area_struct_0xcfbdcf70', _decode_island_area_struct_0xcfbdcf70),
0xd611406b: ('island_area_struct_0xd611406b', _decode_island_area_struct_0xd611406b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct184.py | 0.430985 | 0.248415 | UnknownStruct184.py | 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.UnknownStruct23 import UnknownStruct23
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct59 import UnknownStruct59
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct60 import UnknownStruct60
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct61 import UnknownStruct61
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct62 import UnknownStruct62
@dataclasses.dataclass()
class UnknownStruct48(BaseProperty):
attack_type: enums.AttackType = dataclasses.field(default=enums.AttackType.Unknown1)
unknown: int = dataclasses.field(default=3)
unknown_struct23: UnknownStruct23 = dataclasses.field(default_factory=UnknownStruct23)
unknown_struct59: UnknownStruct59 = dataclasses.field(default_factory=UnknownStruct59)
unknown_struct60: UnknownStruct60 = dataclasses.field(default_factory=UnknownStruct60)
unknown_struct61: UnknownStruct61 = dataclasses.field(default_factory=UnknownStruct61)
unknown_struct62: UnknownStruct62 = dataclasses.field(default_factory=UnknownStruct62)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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))
data.write(b'\x93\xfaH\xa4') # 0x93fa48a4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct23.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3+\xddw') # 0xc32bdd77
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct59.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\x02\xa3\xab') # 0x5902a3ab
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct60.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7z\x8b\xf8') # 0xc77a8bf8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct61.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!17\x85') # 0x21313785
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct62.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=data['unknown'],
unknown_struct23=UnknownStruct23.from_json(data['unknown_struct23']),
unknown_struct59=UnknownStruct59.from_json(data['unknown_struct59']),
unknown_struct60=UnknownStruct60.from_json(data['unknown_struct60']),
unknown_struct61=UnknownStruct61.from_json(data['unknown_struct61']),
unknown_struct62=UnknownStruct62.from_json(data['unknown_struct62']),
)
def to_json(self) -> dict:
return {
'attack_type': self.attack_type.to_json(),
'unknown': self.unknown,
'unknown_struct23': self.unknown_struct23.to_json(),
'unknown_struct59': self.unknown_struct59.to_json(),
'unknown_struct60': self.unknown_struct60.to_json(),
'unknown_struct61': self.unknown_struct61.to_json(),
'unknown_struct62': self.unknown_struct62.to_json(),
}
def _decode_attack_type(data: typing.BinaryIO, property_size: int):
return enums.AttackType.from_stream(data)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct23(data: typing.BinaryIO, property_size: int):
return UnknownStruct23.from_stream(data, property_size)
def _decode_unknown_struct59(data: typing.BinaryIO, property_size: int):
return UnknownStruct59.from_stream(data, property_size)
def _decode_unknown_struct60(data: typing.BinaryIO, property_size: int):
return UnknownStruct60.from_stream(data, property_size)
def _decode_unknown_struct61(data: typing.BinaryIO, property_size: int):
return UnknownStruct61.from_stream(data, property_size)
def _decode_unknown_struct62(data: typing.BinaryIO, property_size: int):
return UnknownStruct62.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', _decode_unknown),
0x93fa48a4: ('unknown_struct23', _decode_unknown_struct23),
0xc32bdd77: ('unknown_struct59', _decode_unknown_struct59),
0x5902a3ab: ('unknown_struct60', _decode_unknown_struct60),
0xc77a8bf8: ('unknown_struct61', _decode_unknown_struct61),
0x21313785: ('unknown_struct62', _decode_unknown_struct62),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct48.py | 0.615897 | 0.3002 | UnknownStruct48.py | 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.ForestBossStructC import ForestBossStructC
@dataclasses.dataclass()
class UnknownStruct94(BaseProperty):
forest_boss_struct_c_0x63f77b98: ForestBossStructC = dataclasses.field(default_factory=ForestBossStructC)
forest_boss_struct_c_0x8561e02d: ForestBossStructC = dataclasses.field(default_factory=ForestBossStructC)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'c\xf7{\x98') # 0x63f77b98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_c_0x63f77b98.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x85a\xe0-') # 0x8561e02d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forest_boss_struct_c_0x8561e02d.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(
forest_boss_struct_c_0x63f77b98=ForestBossStructC.from_json(data['forest_boss_struct_c_0x63f77b98']),
forest_boss_struct_c_0x8561e02d=ForestBossStructC.from_json(data['forest_boss_struct_c_0x8561e02d']),
)
def to_json(self) -> dict:
return {
'forest_boss_struct_c_0x63f77b98': self.forest_boss_struct_c_0x63f77b98.to_json(),
'forest_boss_struct_c_0x8561e02d': self.forest_boss_struct_c_0x8561e02d.to_json(),
}
def _decode_forest_boss_struct_c_0x63f77b98(data: typing.BinaryIO, property_size: int):
return ForestBossStructC.from_stream(data, property_size)
def _decode_forest_boss_struct_c_0x8561e02d(data: typing.BinaryIO, property_size: int):
return ForestBossStructC.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x63f77b98: ('forest_boss_struct_c_0x63f77b98', _decode_forest_boss_struct_c_0x63f77b98),
0x8561e02d: ('forest_boss_struct_c_0x8561e02d', _decode_forest_boss_struct_c_0x8561e02d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct94.py | 0.622689 | 0.384074 | UnknownStruct94.py | 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 LocomotionContextEnum(BaseProperty):
locomotion_context: enums.LocomotionContext = dataclasses.field(default=enums.LocomotionContext.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'\xa9\xf5\xd5@') # 0xa9f5d540
data.write(b'\x00\x04') # size
self.locomotion_context.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
locomotion_context=enums.LocomotionContext.from_json(data['locomotion_context']),
)
def to_json(self) -> dict:
return {
'locomotion_context': self.locomotion_context.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0xa9f5d540)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[LocomotionContextEnum]:
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 LocomotionContextEnum(
enums.LocomotionContext(dec[2]),
)
def _decode_locomotion_context(data: typing.BinaryIO, property_size: int):
return enums.LocomotionContext.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa9f5d540: ('locomotion_context', _decode_locomotion_context),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/LocomotionContextEnum.py | 0.618665 | 0.258747 | LocomotionContextEnum.py | 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 UnknownStruct248(BaseProperty):
camera_fade: bool = dataclasses.field(default=True)
camera_fade_out_delay_time: float = dataclasses.field(default=0.800000011920929)
camera_fade_out_delay_time_after_deathfall: float = dataclasses.field(default=0.20000000298023224)
camera_fade_out_time: float = dataclasses.field(default=1.5)
camera_fade_in_time: float = dataclasses.field(default=1.5)
death_transition_time: float = dataclasses.field(default=2.1500000953674316)
superguide_death_transition_time: float = dataclasses.field(default=3.5)
volume_fade_out_time: float = dataclasses.field(default=0.75)
volume_fade_in_time: float = dataclasses.field(default=0.75)
unknown: str = dataclasses.field(default='')
balloon_decrement_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\x9ab\x10\xd3') # 0x9a6210d3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.camera_fade))
data.write(b'tf\xf0H') # 0x7466f048
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_fade_out_delay_time))
data.write(b'\xb0\xaf9\t') # 0xb0af3909
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_fade_out_delay_time_after_deathfall))
data.write(b'\xc3\xdd\x83\x89') # 0xc3dd8389
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_fade_out_time))
data.write(b'\xbb\xd6\x17,') # 0xbbd6172c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_fade_in_time))
data.write(b"o3'\x01") # 0x6f332701
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.death_transition_time))
data.write(b'\xd3\xc7\xa4\xfa') # 0xd3c7a4fa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.superguide_death_transition_time))
data.write(b'/\x9d\xedK') # 0x2f9ded4b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_fade_out_time))
data.write(b'\x98J\xf3\xed') # 0x984af3ed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_fade_in_time))
data.write(b'+\xd2\xae2') # 0x2bd2ae32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|Q\x96b') # 0x7c519662
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.balloon_decrement_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
camera_fade=data['camera_fade'],
camera_fade_out_delay_time=data['camera_fade_out_delay_time'],
camera_fade_out_delay_time_after_deathfall=data['camera_fade_out_delay_time_after_deathfall'],
camera_fade_out_time=data['camera_fade_out_time'],
camera_fade_in_time=data['camera_fade_in_time'],
death_transition_time=data['death_transition_time'],
superguide_death_transition_time=data['superguide_death_transition_time'],
volume_fade_out_time=data['volume_fade_out_time'],
volume_fade_in_time=data['volume_fade_in_time'],
unknown=data['unknown'],
balloon_decrement_sound=data['balloon_decrement_sound'],
)
def to_json(self) -> dict:
return {
'camera_fade': self.camera_fade,
'camera_fade_out_delay_time': self.camera_fade_out_delay_time,
'camera_fade_out_delay_time_after_deathfall': self.camera_fade_out_delay_time_after_deathfall,
'camera_fade_out_time': self.camera_fade_out_time,
'camera_fade_in_time': self.camera_fade_in_time,
'death_transition_time': self.death_transition_time,
'superguide_death_transition_time': self.superguide_death_transition_time,
'volume_fade_out_time': self.volume_fade_out_time,
'volume_fade_in_time': self.volume_fade_in_time,
'unknown': self.unknown,
'balloon_decrement_sound': self.balloon_decrement_sound,
}
def _decode_camera_fade(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_camera_fade_out_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_fade_out_delay_time_after_deathfall(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_transition_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_superguide_death_transition_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume_fade_in_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")
def _decode_balloon_decrement_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]]] = {
0x9a6210d3: ('camera_fade', _decode_camera_fade),
0x7466f048: ('camera_fade_out_delay_time', _decode_camera_fade_out_delay_time),
0xb0af3909: ('camera_fade_out_delay_time_after_deathfall', _decode_camera_fade_out_delay_time_after_deathfall),
0xc3dd8389: ('camera_fade_out_time', _decode_camera_fade_out_time),
0xbbd6172c: ('camera_fade_in_time', _decode_camera_fade_in_time),
0x6f332701: ('death_transition_time', _decode_death_transition_time),
0xd3c7a4fa: ('superguide_death_transition_time', _decode_superguide_death_transition_time),
0x2f9ded4b: ('volume_fade_out_time', _decode_volume_fade_out_time),
0x984af3ed: ('volume_fade_in_time', _decode_volume_fade_in_time),
0x2bd2ae32: ('unknown', _decode_unknown),
0x7c519662: ('balloon_decrement_sound', _decode_balloon_decrement_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct248.py | 0.617051 | 0.229319 | UnknownStruct248.py | 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 UnknownStruct190(BaseProperty):
unknown: int = dataclasses.field(default=1)
beam_duration: 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\x02') # 2 properties
data.write(b'\x8aX\xa7\xf8') # 0x8a58a7f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'GJ\x91\xdb') # 0x474a91db
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_duration))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
beam_duration=data['beam_duration'],
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'beam_duration': self.beam_duration,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8a58a7f8, 0x474a91db)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct190]:
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 UnknownStruct190(
dec[2],
dec[5],
)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_beam_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]]] = {
0x8a58a7f8: ('unknown', _decode_unknown),
0x474a91db: ('beam_duration', _decode_beam_duration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct190.py | 0.659295 | 0.301028 | UnknownStruct190.py | 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.UnknownStruct196 import UnknownStruct196
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct197 import UnknownStruct197
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct198 import UnknownStruct198
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct199 import UnknownStruct199
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct200 import UnknownStruct200
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct201 import UnknownStruct201
@dataclasses.dataclass()
class ProjectileMotionData(BaseProperty):
motion_type: enums.MotionType = dataclasses.field(default=enums.MotionType.Unknown5)
unknown_struct196: UnknownStruct196 = dataclasses.field(default_factory=UnknownStruct196)
unknown_struct197: UnknownStruct197 = dataclasses.field(default_factory=UnknownStruct197)
unknown_struct198: UnknownStruct198 = dataclasses.field(default_factory=UnknownStruct198)
unknown_struct199: UnknownStruct199 = dataclasses.field(default_factory=UnknownStruct199)
unknown_struct200: UnknownStruct200 = dataclasses.field(default_factory=UnknownStruct200)
unknown_struct201: UnknownStruct201 = dataclasses.field(default_factory=UnknownStruct201)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\x94\x8a\xf5q') # 0x948af571
data.write(b'\x00\x04') # size
self.motion_type.to_stream(data)
data.write(b'\xd1]\xf9\xa6') # 0xd15df9a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct196.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa3\xa5\x8c\x06') # 0xa3a58c06
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct197.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\xc6\x1eH') # 0x59c61e48
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct198.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\x98u\x1f') # 0x8698751f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct199.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe\x92W\xce') # 0xfe9257ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct200.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'`\x8e\x17W') # 0x608e1757
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct201.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=enums.MotionType.from_json(data['motion_type']),
unknown_struct196=UnknownStruct196.from_json(data['unknown_struct196']),
unknown_struct197=UnknownStruct197.from_json(data['unknown_struct197']),
unknown_struct198=UnknownStruct198.from_json(data['unknown_struct198']),
unknown_struct199=UnknownStruct199.from_json(data['unknown_struct199']),
unknown_struct200=UnknownStruct200.from_json(data['unknown_struct200']),
unknown_struct201=UnknownStruct201.from_json(data['unknown_struct201']),
)
def to_json(self) -> dict:
return {
'motion_type': self.motion_type.to_json(),
'unknown_struct196': self.unknown_struct196.to_json(),
'unknown_struct197': self.unknown_struct197.to_json(),
'unknown_struct198': self.unknown_struct198.to_json(),
'unknown_struct199': self.unknown_struct199.to_json(),
'unknown_struct200': self.unknown_struct200.to_json(),
'unknown_struct201': self.unknown_struct201.to_json(),
}
def _decode_motion_type(data: typing.BinaryIO, property_size: int):
return enums.MotionType.from_stream(data)
def _decode_unknown_struct196(data: typing.BinaryIO, property_size: int):
return UnknownStruct196.from_stream(data, property_size)
def _decode_unknown_struct197(data: typing.BinaryIO, property_size: int):
return UnknownStruct197.from_stream(data, property_size)
def _decode_unknown_struct198(data: typing.BinaryIO, property_size: int):
return UnknownStruct198.from_stream(data, property_size)
def _decode_unknown_struct199(data: typing.BinaryIO, property_size: int):
return UnknownStruct199.from_stream(data, property_size)
def _decode_unknown_struct200(data: typing.BinaryIO, property_size: int):
return UnknownStruct200.from_stream(data, property_size)
def _decode_unknown_struct201(data: typing.BinaryIO, property_size: int):
return UnknownStruct201.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),
0xd15df9a6: ('unknown_struct196', _decode_unknown_struct196),
0xa3a58c06: ('unknown_struct197', _decode_unknown_struct197),
0x59c61e48: ('unknown_struct198', _decode_unknown_struct198),
0x8698751f: ('unknown_struct199', _decode_unknown_struct199),
0xfe9257ce: ('unknown_struct200', _decode_unknown_struct200),
0x608e1757: ('unknown_struct201', _decode_unknown_struct201),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ProjectileMotionData.py | 0.629091 | 0.215433 | ProjectileMotionData.py | 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.MaterialType import MaterialType
@dataclasses.dataclass()
class ClingPathControlData(BaseProperty):
cling_path_control_struct: MaterialType = dataclasses.field(default_factory=MaterialType)
can_player_walk_off_cling: bool = dataclasses.field(default=False)
lock_distance_override: float = dataclasses.field(default=0.0)
use_fixed_lateral_jump: enums.UseFixedLateralJump = dataclasses.field(default=enums.UseFixedLateralJump.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xfa\x16h\x86') # 0xfa166886
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cling_path_control_struct.to_stream(data, default_override={'material_type': 4042527608})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7\x0b\xef\xc0') # 0xf70befc0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_player_walk_off_cling))
data.write(b'\xd7\xd2\xb3\xde') # 0xd7d2b3de
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lock_distance_override))
data.write(b"\x8c\x99'\xc2") # 0x8c9927c2
data.write(b'\x00\x04') # size
self.use_fixed_lateral_jump.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
cling_path_control_struct=MaterialType.from_json(data['cling_path_control_struct']),
can_player_walk_off_cling=data['can_player_walk_off_cling'],
lock_distance_override=data['lock_distance_override'],
use_fixed_lateral_jump=enums.UseFixedLateralJump.from_json(data['use_fixed_lateral_jump']),
)
def to_json(self) -> dict:
return {
'cling_path_control_struct': self.cling_path_control_struct.to_json(),
'can_player_walk_off_cling': self.can_player_walk_off_cling,
'lock_distance_override': self.lock_distance_override,
'use_fixed_lateral_jump': self.use_fixed_lateral_jump.to_json(),
}
def _decode_cling_path_control_struct(data: typing.BinaryIO, property_size: int):
return MaterialType.from_stream(data, property_size, default_override={'material_type': 4042527608})
def _decode_can_player_walk_off_cling(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_lock_distance_override(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_fixed_lateral_jump(data: typing.BinaryIO, property_size: int):
return enums.UseFixedLateralJump.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xfa166886: ('cling_path_control_struct', _decode_cling_path_control_struct),
0xf70befc0: ('can_player_walk_off_cling', _decode_can_player_walk_off_cling),
0xd7d2b3de: ('lock_distance_override', _decode_lock_distance_override),
0x8c9927c2: ('use_fixed_lateral_jump', _decode_use_fixed_lateral_jump),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ClingPathControlData.py | 0.680666 | 0.281106 | ClingPathControlData.py | 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 TriggerShape(BaseProperty):
shape: int = dataclasses.field(default=1210786545) # Choice
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\t\xec\xee\x0c') # 0x9ecee0c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shape))
@classmethod
def from_json(cls, data: dict):
return cls(
shape=data['shape'],
)
def to_json(self) -> dict:
return {
'shape': self.shape,
}
_FAST_FORMAT = None
_FAST_IDS = (0x9ecee0c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TriggerShape]:
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 TriggerShape(
dec[2],
)
def _decode_shape(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]]] = {
0x9ecee0c: ('shape', _decode_shape),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/TriggerShape.py | 0.63375 | 0.30516 | TriggerShape.py | 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
@dataclasses.dataclass()
class ShadowData(BaseProperty):
unknown_0xcecb77dd: bool = dataclasses.field(default=False)
shadow_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
edge_adjust: enums.EdgeAdjust = dataclasses.field(default=enums.EdgeAdjust.Unknown1)
minimum_opacity: float = dataclasses.field(default=0.25)
maximum_opacity: float = dataclasses.field(default=0.75)
unknown_0x1524c118: float = dataclasses.field(default=0.25)
unknown_0xc7c4c8a9: float = dataclasses.field(default=1.0)
unknown_0x565c73a2: float = dataclasses.field(default=20.0)
floor_offset: float = dataclasses.field(default=0.05000000074505806)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xce\xcbw\xdd') # 0xcecb77dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcecb77dd))
data.write(b'd\xc0\xc5O') # 0x64c0c54f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.shadow_texture))
data.write(b'y\xcf\xa7u') # 0x79cfa775
data.write(b'\x00\x04') # size
self.edge_adjust.to_stream(data)
data.write(b'\x1c\xf3\xf4h') # 0x1cf3f468
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_opacity))
data.write(b'\xbb\xc7t\x11') # 0xbbc77411
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_opacity))
data.write(b'\x15$\xc1\x18') # 0x1524c118
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1524c118))
data.write(b'\xc7\xc4\xc8\xa9') # 0xc7c4c8a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc7c4c8a9))
data.write(b'V\\s\xa2') # 0x565c73a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x565c73a2))
data.write(b'\x80\x8e\x9e2') # 0x808e9e32
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_offset))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xcecb77dd=data['unknown_0xcecb77dd'],
shadow_texture=data['shadow_texture'],
edge_adjust=enums.EdgeAdjust.from_json(data['edge_adjust']),
minimum_opacity=data['minimum_opacity'],
maximum_opacity=data['maximum_opacity'],
unknown_0x1524c118=data['unknown_0x1524c118'],
unknown_0xc7c4c8a9=data['unknown_0xc7c4c8a9'],
unknown_0x565c73a2=data['unknown_0x565c73a2'],
floor_offset=data['floor_offset'],
)
def to_json(self) -> dict:
return {
'unknown_0xcecb77dd': self.unknown_0xcecb77dd,
'shadow_texture': self.shadow_texture,
'edge_adjust': self.edge_adjust.to_json(),
'minimum_opacity': self.minimum_opacity,
'maximum_opacity': self.maximum_opacity,
'unknown_0x1524c118': self.unknown_0x1524c118,
'unknown_0xc7c4c8a9': self.unknown_0xc7c4c8a9,
'unknown_0x565c73a2': self.unknown_0x565c73a2,
'floor_offset': self.floor_offset,
}
_FAST_FORMAT = None
_FAST_IDS = (0xcecb77dd, 0x64c0c54f, 0x79cfa775, 0x1cf3f468, 0xbbc77411, 0x1524c118, 0xc7c4c8a9, 0x565c73a2, 0x808e9e32)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ShadowData]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LHQLHLLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(91))
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 ShadowData(
dec[2],
dec[5],
enums.EdgeAdjust(dec[8]),
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_unknown_0xcecb77dd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_shadow_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_edge_adjust(data: typing.BinaryIO, property_size: int):
return enums.EdgeAdjust.from_stream(data)
def _decode_minimum_opacity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_opacity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1524c118(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc7c4c8a9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x565c73a2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_floor_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]]] = {
0xcecb77dd: ('unknown_0xcecb77dd', _decode_unknown_0xcecb77dd),
0x64c0c54f: ('shadow_texture', _decode_shadow_texture),
0x79cfa775: ('edge_adjust', _decode_edge_adjust),
0x1cf3f468: ('minimum_opacity', _decode_minimum_opacity),
0xbbc77411: ('maximum_opacity', _decode_maximum_opacity),
0x1524c118: ('unknown_0x1524c118', _decode_unknown_0x1524c118),
0xc7c4c8a9: ('unknown_0xc7c4c8a9', _decode_unknown_0xc7c4c8a9),
0x565c73a2: ('unknown_0x565c73a2', _decode_unknown_0x565c73a2),
0x808e9e32: ('floor_offset', _decode_floor_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ShadowData.py | 0.648689 | 0.218576 | ShadowData.py | 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 KongStalledDescentData(BaseProperty):
rate_of_descent: float = dataclasses.field(default=3.0)
thrust_ramp_in_time: float = dataclasses.field(default=0.3499999940395355)
descent_control_scalar: float = dataclasses.field(default=1.25)
thrust_duration: float = dataclasses.field(default=2.5)
rocket_pack_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
rocket_pack_smoke_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
rocket_pack_smoke_trail_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
rocket_pack_effect_locator: str = dataclasses.field(default='')
rocket_pack_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xbdaaa9b1: Spline = dataclasses.field(default_factory=Spline)
unknown_0x7e50a6d2: Spline = dataclasses.field(default_factory=Spline)
unknown_0x075f730c: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\x88H\xe3A') # 0x8848e341
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rate_of_descent))
data.write(b'\xd9\xff\xddS') # 0xd9ffdd53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.thrust_ramp_in_time))
data.write(b'(\xe1\xa3\x9c') # 0x28e1a39c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.descent_control_scalar))
data.write(b'\xe8\xc0m~') # 0xe8c06d7e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.thrust_duration))
data.write(b'\xbf=\xd0\xe1') # 0xbf3dd0e1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rocket_pack_effect))
data.write(b"\\'\x1c\x9a") # 0x5c271c9a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rocket_pack_smoke_effect))
data.write(b'Q!d\x8e') # 0x5121648e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rocket_pack_smoke_trail_effect))
data.write(b'\xc9\xd7"T') # 0xc9d72254
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.rocket_pack_effect_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2\xac\xf0\xfa') # 0xa2acf0fa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rocket_pack_sound))
data.write(b'\xbd\xaa\xa9\xb1') # 0xbdaaa9b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xbdaaa9b1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~P\xa6\xd2') # 0x7e50a6d2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7e50a6d2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x07_s\x0c') # 0x75f730c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x075f730c.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(
rate_of_descent=data['rate_of_descent'],
thrust_ramp_in_time=data['thrust_ramp_in_time'],
descent_control_scalar=data['descent_control_scalar'],
thrust_duration=data['thrust_duration'],
rocket_pack_effect=data['rocket_pack_effect'],
rocket_pack_smoke_effect=data['rocket_pack_smoke_effect'],
rocket_pack_smoke_trail_effect=data['rocket_pack_smoke_trail_effect'],
rocket_pack_effect_locator=data['rocket_pack_effect_locator'],
rocket_pack_sound=data['rocket_pack_sound'],
unknown_0xbdaaa9b1=Spline.from_json(data['unknown_0xbdaaa9b1']),
unknown_0x7e50a6d2=Spline.from_json(data['unknown_0x7e50a6d2']),
unknown_0x075f730c=Spline.from_json(data['unknown_0x075f730c']),
)
def to_json(self) -> dict:
return {
'rate_of_descent': self.rate_of_descent,
'thrust_ramp_in_time': self.thrust_ramp_in_time,
'descent_control_scalar': self.descent_control_scalar,
'thrust_duration': self.thrust_duration,
'rocket_pack_effect': self.rocket_pack_effect,
'rocket_pack_smoke_effect': self.rocket_pack_smoke_effect,
'rocket_pack_smoke_trail_effect': self.rocket_pack_smoke_trail_effect,
'rocket_pack_effect_locator': self.rocket_pack_effect_locator,
'rocket_pack_sound': self.rocket_pack_sound,
'unknown_0xbdaaa9b1': self.unknown_0xbdaaa9b1.to_json(),
'unknown_0x7e50a6d2': self.unknown_0x7e50a6d2.to_json(),
'unknown_0x075f730c': self.unknown_0x075f730c.to_json(),
}
def _decode_rate_of_descent(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_thrust_ramp_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_descent_control_scalar(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_thrust_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rocket_pack_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rocket_pack_smoke_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rocket_pack_smoke_trail_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_rocket_pack_effect_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_rocket_pack_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xbdaaa9b1(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x7e50a6d2(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x075f730c(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]]] = {
0x8848e341: ('rate_of_descent', _decode_rate_of_descent),
0xd9ffdd53: ('thrust_ramp_in_time', _decode_thrust_ramp_in_time),
0x28e1a39c: ('descent_control_scalar', _decode_descent_control_scalar),
0xe8c06d7e: ('thrust_duration', _decode_thrust_duration),
0xbf3dd0e1: ('rocket_pack_effect', _decode_rocket_pack_effect),
0x5c271c9a: ('rocket_pack_smoke_effect', _decode_rocket_pack_smoke_effect),
0x5121648e: ('rocket_pack_smoke_trail_effect', _decode_rocket_pack_smoke_trail_effect),
0xc9d72254: ('rocket_pack_effect_locator', _decode_rocket_pack_effect_locator),
0xa2acf0fa: ('rocket_pack_sound', _decode_rocket_pack_sound),
0xbdaaa9b1: ('unknown_0xbdaaa9b1', _decode_unknown_0xbdaaa9b1),
0x7e50a6d2: ('unknown_0x7e50a6d2', _decode_unknown_0x7e50a6d2),
0x75f730c: ('unknown_0x075f730c', _decode_unknown_0x075f730c),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongStalledDescentData.py | 0.563618 | 0.170163 | KongStalledDescentData.py | 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 UnknownStruct70(BaseProperty):
unknown_0x3b6740f1: float = dataclasses.field(default=2.0)
unknown_0x8130b0d8: float = dataclasses.field(default=1.0)
ignore_upper_lower_bounds: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b';g@\xf1') # 0x3b6740f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3b6740f1))
data.write(b'\x810\xb0\xd8') # 0x8130b0d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8130b0d8))
data.write(b'hYR\xe3') # 0x685952e3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_upper_lower_bounds))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x3b6740f1=data['unknown_0x3b6740f1'],
unknown_0x8130b0d8=data['unknown_0x8130b0d8'],
ignore_upper_lower_bounds=data['ignore_upper_lower_bounds'],
)
def to_json(self) -> dict:
return {
'unknown_0x3b6740f1': self.unknown_0x3b6740f1,
'unknown_0x8130b0d8': self.unknown_0x8130b0d8,
'ignore_upper_lower_bounds': self.ignore_upper_lower_bounds,
}
_FAST_FORMAT = None
_FAST_IDS = (0x3b6740f1, 0x8130b0d8, 0x685952e3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct70]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(27))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct70(
dec[2],
dec[5],
dec[8],
)
def _decode_unknown_0x3b6740f1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8130b0d8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ignore_upper_lower_bounds(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]]] = {
0x3b6740f1: ('unknown_0x3b6740f1', _decode_unknown_0x3b6740f1),
0x8130b0d8: ('unknown_0x8130b0d8', _decode_unknown_0x8130b0d8),
0x685952e3: ('ignore_upper_lower_bounds', _decode_ignore_upper_lower_bounds),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct70.py | 0.638385 | 0.311846 | UnknownStruct70.py | 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 UnknownStruct288(BaseProperty):
stage_width: float = dataclasses.field(default=32.0)
unknown_0xf2ec945d: float = dataclasses.field(default=8.0)
unknown_0xceebc469: float = dataclasses.field(default=10.0)
unknown_0x90ef04a5: float = dataclasses.field(default=50.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
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'\xe6\x89&#') # 0xe6892623
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stage_width))
data.write(b'\xf2\xec\x94]') # 0xf2ec945d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf2ec945d))
data.write(b'\xce\xeb\xc4i') # 0xceebc469
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xceebc469))
data.write(b'\x90\xef\x04\xa5') # 0x90ef04a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x90ef04a5))
@classmethod
def from_json(cls, data: dict):
return cls(
stage_width=data['stage_width'],
unknown_0xf2ec945d=data['unknown_0xf2ec945d'],
unknown_0xceebc469=data['unknown_0xceebc469'],
unknown_0x90ef04a5=data['unknown_0x90ef04a5'],
)
def to_json(self) -> dict:
return {
'stage_width': self.stage_width,
'unknown_0xf2ec945d': self.unknown_0xf2ec945d,
'unknown_0xceebc469': self.unknown_0xceebc469,
'unknown_0x90ef04a5': self.unknown_0x90ef04a5,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe6892623, 0xf2ec945d, 0xceebc469, 0x90ef04a5)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct288]:
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 UnknownStruct288(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_stage_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf2ec945d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xceebc469(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x90ef04a5(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]]] = {
0xe6892623: ('stage_width', _decode_stage_width),
0xf2ec945d: ('unknown_0xf2ec945d', _decode_unknown_0xf2ec945d),
0xceebc469: ('unknown_0xceebc469', _decode_unknown_0xceebc469),
0x90ef04a5: ('unknown_0x90ef04a5', _decode_unknown_0x90ef04a5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct288.py | 0.604632 | 0.287296 | UnknownStruct288.py | 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 PickupRelayStruct(BaseProperty):
message1_chance: float = dataclasses.field(default=0.0)
message2_chance: float = dataclasses.field(default=0.0)
message3_chance: float = dataclasses.field(default=0.0)
message4_chance: float = dataclasses.field(default=0.0)
message5_chance: float = dataclasses.field(default=0.0)
message6_chance: float = dataclasses.field(default=0.0)
message7_chance: float = dataclasses.field(default=0.0)
message8_chance: float = dataclasses.field(default=0.0)
message9_chance: float = dataclasses.field(default=0.0)
message10_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]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b'\xfd\xe3\xa4\xf5') # 0xfde3a4f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message1_chance))
data.write(b'\x8a}v\x05') # 0x8a7d7605
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message2_chance))
data.write(b'\x11\xd8:j') # 0x11d83a6a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message3_chance))
data.write(b'e@\xd3\xe5') # 0x6540d3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message4_chance))
data.write(b'\xfe\xe5\x9f\x8a') # 0xfee59f8a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message5_chance))
data.write(b'\x89{Mz') # 0x897b4d7a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message6_chance))
data.write(b'\x12\xde\x01\x15') # 0x12de0115
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message7_chance))
data.write(b'`J\x9ed') # 0x604a9e64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message8_chance))
data.write(b'\xfb\xef\xd2\x0b') # 0xfbefd20b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message9_chance))
data.write(b'T\xe8\xc1\x8a') # 0x54e8c18a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.message10_chance))
@classmethod
def from_json(cls, data: dict):
return cls(
message1_chance=data['message1_chance'],
message2_chance=data['message2_chance'],
message3_chance=data['message3_chance'],
message4_chance=data['message4_chance'],
message5_chance=data['message5_chance'],
message6_chance=data['message6_chance'],
message7_chance=data['message7_chance'],
message8_chance=data['message8_chance'],
message9_chance=data['message9_chance'],
message10_chance=data['message10_chance'],
)
def to_json(self) -> dict:
return {
'message1_chance': self.message1_chance,
'message2_chance': self.message2_chance,
'message3_chance': self.message3_chance,
'message4_chance': self.message4_chance,
'message5_chance': self.message5_chance,
'message6_chance': self.message6_chance,
'message7_chance': self.message7_chance,
'message8_chance': self.message8_chance,
'message9_chance': self.message9_chance,
'message10_chance': self.message10_chance,
}
_FAST_FORMAT = None
_FAST_IDS = (0xfde3a4f5, 0x8a7d7605, 0x11d83a6a, 0x6540d3e5, 0xfee59f8a, 0x897b4d7a, 0x12de0115, 0x604a9e64, 0xfbefd20b, 0x54e8c18a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PickupRelayStruct]:
if property_count != 10:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(100))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27]) != _FAST_IDS:
data.seek(before)
return None
return PickupRelayStruct(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
)
def _decode_message1_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message2_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message3_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message4_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message5_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message6_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message7_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message8_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message9_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_message10_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]]] = {
0xfde3a4f5: ('message1_chance', _decode_message1_chance),
0x8a7d7605: ('message2_chance', _decode_message2_chance),
0x11d83a6a: ('message3_chance', _decode_message3_chance),
0x6540d3e5: ('message4_chance', _decode_message4_chance),
0xfee59f8a: ('message5_chance', _decode_message5_chance),
0x897b4d7a: ('message6_chance', _decode_message6_chance),
0x12de0115: ('message7_chance', _decode_message7_chance),
0x604a9e64: ('message8_chance', _decode_message8_chance),
0xfbefd20b: ('message9_chance', _decode_message9_chance),
0x54e8c18a: ('message10_chance', _decode_message10_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PickupRelayStruct.py | 0.651466 | 0.236891 | PickupRelayStruct.py | 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 UnknownStruct158(BaseProperty):
caud_0x31bd7c5d: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud_0x2a3fc965: 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'1\xbd|]') # 0x31bd7c5d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x31bd7c5d))
data.write(b'*?\xc9e') # 0x2a3fc965
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud_0x2a3fc965))
@classmethod
def from_json(cls, data: dict):
return cls(
caud_0x31bd7c5d=data['caud_0x31bd7c5d'],
caud_0x2a3fc965=data['caud_0x2a3fc965'],
)
def to_json(self) -> dict:
return {
'caud_0x31bd7c5d': self.caud_0x31bd7c5d,
'caud_0x2a3fc965': self.caud_0x2a3fc965,
}
_FAST_FORMAT = None
_FAST_IDS = (0x31bd7c5d, 0x2a3fc965)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct158]:
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 UnknownStruct158(
dec[2],
dec[5],
)
def _decode_caud_0x31bd7c5d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caud_0x2a3fc965(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]]] = {
0x31bd7c5d: ('caud_0x31bd7c5d', _decode_caud_0x31bd7c5d),
0x2a3fc965: ('caud_0x2a3fc965', _decode_caud_0x2a3fc965),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct158.py | 0.598312 | 0.284255 | UnknownStruct158.py | 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 UnknownStruct84(BaseProperty):
limits: enums.Limits = dataclasses.field(default=enums.Limits.Unknown1)
unknown: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
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'<\xc8_\x81') # 0x3cc85f81
data.write(b'\x00\x04') # size
self.limits.to_stream(data)
data.write(b'\xc6\xd0\xd3\xa4') # 0xc6d0d3a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
limits=enums.Limits.from_json(data['limits']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'limits': self.limits.to_json(),
'unknown': self.unknown,
}
_FAST_FORMAT = None
_FAST_IDS = (0x3cc85f81, 0xc6d0d3a4)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct84]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct84(
enums.Limits(dec[2]),
dec[5],
)
def _decode_limits(data: typing.BinaryIO, property_size: int):
return enums.Limits.from_stream(data)
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]]] = {
0x3cc85f81: ('limits', _decode_limits),
0xc6d0d3a4: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct84.py | 0.652574 | 0.300367 | UnknownStruct84.py | 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 UnknownStruct250(BaseProperty):
horizontal_acceleration: float = dataclasses.field(default=40.0)
unknown_0xd8109ad6: float = dataclasses.field(default=16.0)
initial_vertical_speed: float = dataclasses.field(default=14.0)
initial_disable_controls_time: float = dataclasses.field(default=0.75)
unknown_0xbc609c25: float = dataclasses.field(default=-25.0)
unknown_0xa5fea1f2: float = dataclasses.field(default=50.0)
unknown_0x7ae84b42: float = dataclasses.field(default=20.0)
unknown_0xf9670ac1: float = dataclasses.field(default=5.0)
unknown_0x76683dd3: float = dataclasses.field(default=16.0)
unknown_0x21666d90: float = dataclasses.field(default=0.0)
bounce_k: float = dataclasses.field(default=0.30000001192092896)
unknown_0x0ef5b050: float = dataclasses.field(default=0.20000000298023224)
neutral_pitch: float = dataclasses.field(default=-70.0)
pitch_acceleration: float = dataclasses.field(default=5.0)
pitch_limit: float = dataclasses.field(default=50.0)
unknown_0xce155a8d: float = dataclasses.field(default=0.10000000149011612)
unknown_0x1952baf3: float = dataclasses.field(default=0.10000000149011612)
unknown_0x0fb70190: float = dataclasses.field(default=-16.0)
engine_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
engine_sound_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
engine_sound_pitch: Spline = dataclasses.field(default_factory=Spline)
engine_sound_volume: Spline = dataclasses.field(default_factory=Spline)
engine_sound2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
engine_sound2_low_pass_filter: Spline = dataclasses.field(default_factory=Spline)
engine_sound2_pitch: Spline = dataclasses.field(default_factory=Spline)
engine_sound2_volume: Spline = dataclasses.field(default_factory=Spline)
crash_velocity_damping: float = dataclasses.field(default=0.6600000262260437)
vertical_crash_velocity: float = dataclasses.field(default=20.0)
unknown_0x6763516a: float = dataclasses.field(default=5.0)
unknown_0x0755ff5c: float = dataclasses.field(default=1.0)
unknown_0xaeaf14ad: float = dataclasses.field(default=18.0)
unknown_0xfecde575: float = dataclasses.field(default=-90.0)
exhaust_effect_scalar: 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!') # 33 properties
data.write(b'\x07Vz\x08') # 0x7567a08
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horizontal_acceleration))
data.write(b'\xd8\x10\x9a\xd6') # 0xd8109ad6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd8109ad6))
data.write(b'cqC\xa3') # 0x637143a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_vertical_speed))
data.write(b'\xae\xf4i\xe8') # 0xaef469e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_disable_controls_time))
data.write(b'\xbc`\x9c%') # 0xbc609c25
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbc609c25))
data.write(b'\xa5\xfe\xa1\xf2') # 0xa5fea1f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa5fea1f2))
data.write(b'z\xe8KB') # 0x7ae84b42
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7ae84b42))
data.write(b'\xf9g\n\xc1') # 0xf9670ac1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf9670ac1))
data.write(b'vh=\xd3') # 0x76683dd3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76683dd3))
data.write(b'!fm\x90') # 0x21666d90
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x21666d90))
data.write(b'\xf2m\xf1\xd6') # 0xf26df1d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounce_k))
data.write(b'\x0e\xf5\xb0P') # 0xef5b050
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0ef5b050))
data.write(b'\xacS*\x85') # 0xac532a85
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.neutral_pitch))
data.write(b'[\xeax\xca') # 0x5bea78ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch_acceleration))
data.write(b'\xf5\x1a=\x06') # 0xf51a3d06
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch_limit))
data.write(b'\xce\x15Z\x8d') # 0xce155a8d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xce155a8d))
data.write(b'\x19R\xba\xf3') # 0x1952baf3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1952baf3))
data.write(b'\x0f\xb7\x01\x90') # 0xfb70190
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0fb70190))
data.write(b'\xd1\x90\x89\x9c') # 0xd190899c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.engine_sound))
data.write(b'\x827T5') # 0x82375435
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8uY;') # 0xb875593b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdeO\x0c/') # 0xde4f0c2f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'uH\xb8\xaa') # 0x7548b8aa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.engine_sound2))
data.write(b'\x10\xd8\xe5E') # 0x10d8e545
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound2_low_pass_filter.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\x86Hw') # 0xcb864877
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound2_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1V\xf2\x85') # 0xa156f285
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.engine_sound2_volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\x84E\x0b') # 0x3684450b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.crash_velocity_damping))
data.write(b'4\xf4\x13\xe7') # 0x34f413e7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vertical_crash_velocity))
data.write(b'gcQj') # 0x6763516a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6763516a))
data.write(b'\x07U\xff\\') # 0x755ff5c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0755ff5c))
data.write(b'\xae\xaf\x14\xad') # 0xaeaf14ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xaeaf14ad))
data.write(b'\xfe\xcd\xe5u') # 0xfecde575
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfecde575))
data.write(b'"\xdf\x00\x96') # 0x22df0096
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.exhaust_effect_scalar))
@classmethod
def from_json(cls, data: dict):
return cls(
horizontal_acceleration=data['horizontal_acceleration'],
unknown_0xd8109ad6=data['unknown_0xd8109ad6'],
initial_vertical_speed=data['initial_vertical_speed'],
initial_disable_controls_time=data['initial_disable_controls_time'],
unknown_0xbc609c25=data['unknown_0xbc609c25'],
unknown_0xa5fea1f2=data['unknown_0xa5fea1f2'],
unknown_0x7ae84b42=data['unknown_0x7ae84b42'],
unknown_0xf9670ac1=data['unknown_0xf9670ac1'],
unknown_0x76683dd3=data['unknown_0x76683dd3'],
unknown_0x21666d90=data['unknown_0x21666d90'],
bounce_k=data['bounce_k'],
unknown_0x0ef5b050=data['unknown_0x0ef5b050'],
neutral_pitch=data['neutral_pitch'],
pitch_acceleration=data['pitch_acceleration'],
pitch_limit=data['pitch_limit'],
unknown_0xce155a8d=data['unknown_0xce155a8d'],
unknown_0x1952baf3=data['unknown_0x1952baf3'],
unknown_0x0fb70190=data['unknown_0x0fb70190'],
engine_sound=data['engine_sound'],
engine_sound_low_pass_filter=Spline.from_json(data['engine_sound_low_pass_filter']),
engine_sound_pitch=Spline.from_json(data['engine_sound_pitch']),
engine_sound_volume=Spline.from_json(data['engine_sound_volume']),
engine_sound2=data['engine_sound2'],
engine_sound2_low_pass_filter=Spline.from_json(data['engine_sound2_low_pass_filter']),
engine_sound2_pitch=Spline.from_json(data['engine_sound2_pitch']),
engine_sound2_volume=Spline.from_json(data['engine_sound2_volume']),
crash_velocity_damping=data['crash_velocity_damping'],
vertical_crash_velocity=data['vertical_crash_velocity'],
unknown_0x6763516a=data['unknown_0x6763516a'],
unknown_0x0755ff5c=data['unknown_0x0755ff5c'],
unknown_0xaeaf14ad=data['unknown_0xaeaf14ad'],
unknown_0xfecde575=data['unknown_0xfecde575'],
exhaust_effect_scalar=data['exhaust_effect_scalar'],
)
def to_json(self) -> dict:
return {
'horizontal_acceleration': self.horizontal_acceleration,
'unknown_0xd8109ad6': self.unknown_0xd8109ad6,
'initial_vertical_speed': self.initial_vertical_speed,
'initial_disable_controls_time': self.initial_disable_controls_time,
'unknown_0xbc609c25': self.unknown_0xbc609c25,
'unknown_0xa5fea1f2': self.unknown_0xa5fea1f2,
'unknown_0x7ae84b42': self.unknown_0x7ae84b42,
'unknown_0xf9670ac1': self.unknown_0xf9670ac1,
'unknown_0x76683dd3': self.unknown_0x76683dd3,
'unknown_0x21666d90': self.unknown_0x21666d90,
'bounce_k': self.bounce_k,
'unknown_0x0ef5b050': self.unknown_0x0ef5b050,
'neutral_pitch': self.neutral_pitch,
'pitch_acceleration': self.pitch_acceleration,
'pitch_limit': self.pitch_limit,
'unknown_0xce155a8d': self.unknown_0xce155a8d,
'unknown_0x1952baf3': self.unknown_0x1952baf3,
'unknown_0x0fb70190': self.unknown_0x0fb70190,
'engine_sound': self.engine_sound,
'engine_sound_low_pass_filter': self.engine_sound_low_pass_filter.to_json(),
'engine_sound_pitch': self.engine_sound_pitch.to_json(),
'engine_sound_volume': self.engine_sound_volume.to_json(),
'engine_sound2': self.engine_sound2,
'engine_sound2_low_pass_filter': self.engine_sound2_low_pass_filter.to_json(),
'engine_sound2_pitch': self.engine_sound2_pitch.to_json(),
'engine_sound2_volume': self.engine_sound2_volume.to_json(),
'crash_velocity_damping': self.crash_velocity_damping,
'vertical_crash_velocity': self.vertical_crash_velocity,
'unknown_0x6763516a': self.unknown_0x6763516a,
'unknown_0x0755ff5c': self.unknown_0x0755ff5c,
'unknown_0xaeaf14ad': self.unknown_0xaeaf14ad,
'unknown_0xfecde575': self.unknown_0xfecde575,
'exhaust_effect_scalar': self.exhaust_effect_scalar,
}
def _decode_horizontal_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd8109ad6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_vertical_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_disable_controls_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbc609c25(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa5fea1f2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7ae84b42(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf9670ac1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x76683dd3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x21666d90(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bounce_k(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0ef5b050(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_neutral_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pitch_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pitch_limit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xce155a8d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1952baf3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0fb70190(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_engine_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_engine_sound_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_engine_sound2_low_pass_filter(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound2_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_engine_sound2_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_crash_velocity_damping(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vertical_crash_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6763516a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0755ff5c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xaeaf14ad(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfecde575(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_exhaust_effect_scalar(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]]] = {
0x7567a08: ('horizontal_acceleration', _decode_horizontal_acceleration),
0xd8109ad6: ('unknown_0xd8109ad6', _decode_unknown_0xd8109ad6),
0x637143a3: ('initial_vertical_speed', _decode_initial_vertical_speed),
0xaef469e8: ('initial_disable_controls_time', _decode_initial_disable_controls_time),
0xbc609c25: ('unknown_0xbc609c25', _decode_unknown_0xbc609c25),
0xa5fea1f2: ('unknown_0xa5fea1f2', _decode_unknown_0xa5fea1f2),
0x7ae84b42: ('unknown_0x7ae84b42', _decode_unknown_0x7ae84b42),
0xf9670ac1: ('unknown_0xf9670ac1', _decode_unknown_0xf9670ac1),
0x76683dd3: ('unknown_0x76683dd3', _decode_unknown_0x76683dd3),
0x21666d90: ('unknown_0x21666d90', _decode_unknown_0x21666d90),
0xf26df1d6: ('bounce_k', _decode_bounce_k),
0xef5b050: ('unknown_0x0ef5b050', _decode_unknown_0x0ef5b050),
0xac532a85: ('neutral_pitch', _decode_neutral_pitch),
0x5bea78ca: ('pitch_acceleration', _decode_pitch_acceleration),
0xf51a3d06: ('pitch_limit', _decode_pitch_limit),
0xce155a8d: ('unknown_0xce155a8d', _decode_unknown_0xce155a8d),
0x1952baf3: ('unknown_0x1952baf3', _decode_unknown_0x1952baf3),
0xfb70190: ('unknown_0x0fb70190', _decode_unknown_0x0fb70190),
0xd190899c: ('engine_sound', _decode_engine_sound),
0x82375435: ('engine_sound_low_pass_filter', _decode_engine_sound_low_pass_filter),
0xb875593b: ('engine_sound_pitch', _decode_engine_sound_pitch),
0xde4f0c2f: ('engine_sound_volume', _decode_engine_sound_volume),
0x7548b8aa: ('engine_sound2', _decode_engine_sound2),
0x10d8e545: ('engine_sound2_low_pass_filter', _decode_engine_sound2_low_pass_filter),
0xcb864877: ('engine_sound2_pitch', _decode_engine_sound2_pitch),
0xa156f285: ('engine_sound2_volume', _decode_engine_sound2_volume),
0x3684450b: ('crash_velocity_damping', _decode_crash_velocity_damping),
0x34f413e7: ('vertical_crash_velocity', _decode_vertical_crash_velocity),
0x6763516a: ('unknown_0x6763516a', _decode_unknown_0x6763516a),
0x755ff5c: ('unknown_0x0755ff5c', _decode_unknown_0x0755ff5c),
0xaeaf14ad: ('unknown_0xaeaf14ad', _decode_unknown_0xaeaf14ad),
0xfecde575: ('unknown_0xfecde575', _decode_unknown_0xfecde575),
0x22df0096: ('exhaust_effect_scalar', _decode_exhaust_effect_scalar),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct250.py | 0.647464 | 0.204958 | UnknownStruct250.py | 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.IslandHudStruct import IslandHudStruct
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct170 import UnknownStruct170
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct171 import UnknownStruct171
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct172 import UnknownStruct172
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct173 import UnknownStruct173
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct27 import UnknownStruct27
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct174(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
title: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
images: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
music: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unlocked: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
text_background: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
island_hud_struct_0x800073b8: IslandHudStruct = dataclasses.field(default_factory=IslandHudStruct)
island_hud_struct_0x5f71338f: IslandHudStruct = dataclasses.field(default_factory=IslandHudStruct)
island_hud_struct_0x01be492e: IslandHudStruct = dataclasses.field(default_factory=IslandHudStruct)
unknown_struct170: UnknownStruct170 = dataclasses.field(default_factory=UnknownStruct170)
unknown_struct171: UnknownStruct171 = dataclasses.field(default_factory=UnknownStruct171)
unknown_struct172: UnknownStruct172 = dataclasses.field(default_factory=UnknownStruct172)
unknown_struct173: UnknownStruct173 = dataclasses.field(default_factory=UnknownStruct173)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x10') # 16 properties
data.write(b'\x80`R\xcb') # 0x806052cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.gui_frame))
data.write(b's\xe2\x81\x9b') # 0x73e2819b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xf2\x0c\x17') # 0xa4f20c17
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title))
data.write(b'\x1c\xe7k\x90') # 0x1ce76b90
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.images))
data.write(b'\xbb\x19\xd2\xf3') # 0xbb19d2f3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.music))
data.write(b'9f[\xc8') # 0x39665bc8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unlocked))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
data.write(b'\x80\x00s\xb8') # 0x800073b8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_hud_struct_0x800073b8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'_q3\x8f') # 0x5f71338f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_hud_struct_0x5f71338f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01\xbeI.') # 0x1be492e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.island_hud_struct_0x01be492e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x98\xe0\x18$') # 0x98e01824
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct170.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\xe5x\x8c') # 0xf8e5788c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct171.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'I\x83\xb2\x9a') # 0x4983b29a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct172.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x85\x1b\xe4\xbe') # 0x851be4be
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct173.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_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
title=data['title'],
images=data['images'],
music=data['music'],
unlocked=data['unlocked'],
back=data['back'],
back_core=data['back_core'],
text_background=data['text_background'],
island_hud_struct_0x800073b8=IslandHudStruct.from_json(data['island_hud_struct_0x800073b8']),
island_hud_struct_0x5f71338f=IslandHudStruct.from_json(data['island_hud_struct_0x5f71338f']),
island_hud_struct_0x01be492e=IslandHudStruct.from_json(data['island_hud_struct_0x01be492e']),
unknown_struct170=UnknownStruct170.from_json(data['unknown_struct170']),
unknown_struct171=UnknownStruct171.from_json(data['unknown_struct171']),
unknown_struct172=UnknownStruct172.from_json(data['unknown_struct172']),
unknown_struct173=UnknownStruct173.from_json(data['unknown_struct173']),
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_struct27': self.unknown_struct27.to_json(),
'title': self.title,
'images': self.images,
'music': self.music,
'unlocked': self.unlocked,
'back': self.back,
'back_core': self.back_core,
'text_background': self.text_background,
'island_hud_struct_0x800073b8': self.island_hud_struct_0x800073b8.to_json(),
'island_hud_struct_0x5f71338f': self.island_hud_struct_0x5f71338f.to_json(),
'island_hud_struct_0x01be492e': self.island_hud_struct_0x01be492e.to_json(),
'unknown_struct170': self.unknown_struct170.to_json(),
'unknown_struct171': self.unknown_struct171.to_json(),
'unknown_struct172': self.unknown_struct172.to_json(),
'unknown_struct173': self.unknown_struct173.to_json(),
}
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_title(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_images(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_music(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unlocked(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_island_hud_struct_0x800073b8(data: typing.BinaryIO, property_size: int):
return IslandHudStruct.from_stream(data, property_size)
def _decode_island_hud_struct_0x5f71338f(data: typing.BinaryIO, property_size: int):
return IslandHudStruct.from_stream(data, property_size)
def _decode_island_hud_struct_0x01be492e(data: typing.BinaryIO, property_size: int):
return IslandHudStruct.from_stream(data, property_size)
def _decode_unknown_struct170(data: typing.BinaryIO, property_size: int):
return UnknownStruct170.from_stream(data, property_size)
def _decode_unknown_struct171(data: typing.BinaryIO, property_size: int):
return UnknownStruct171.from_stream(data, property_size)
def _decode_unknown_struct172(data: typing.BinaryIO, property_size: int):
return UnknownStruct172.from_stream(data, property_size)
def _decode_unknown_struct173(data: typing.BinaryIO, property_size: int):
return UnknownStruct173.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),
0x73e2819b: ('unknown_struct27', _decode_unknown_struct27),
0xa4f20c17: ('title', _decode_title),
0x1ce76b90: ('images', _decode_images),
0xbb19d2f3: ('music', _decode_music),
0x39665bc8: ('unlocked', _decode_unlocked),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0xe119319b: ('text_background', _decode_text_background),
0x800073b8: ('island_hud_struct_0x800073b8', _decode_island_hud_struct_0x800073b8),
0x5f71338f: ('island_hud_struct_0x5f71338f', _decode_island_hud_struct_0x5f71338f),
0x1be492e: ('island_hud_struct_0x01be492e', _decode_island_hud_struct_0x01be492e),
0x98e01824: ('unknown_struct170', _decode_unknown_struct170),
0xf8e5788c: ('unknown_struct171', _decode_unknown_struct171),
0x4983b29a: ('unknown_struct172', _decode_unknown_struct172),
0x851be4be: ('unknown_struct173', _decode_unknown_struct173),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct174.py | 0.507812 | 0.200734 | UnknownStruct174.py | 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.UnknownStruct279 import UnknownStruct279
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct280 import UnknownStruct280
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct281 import UnknownStruct281
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct282 import UnknownStruct282
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct283 import UnknownStruct283
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct284 import UnknownStruct284
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct58 import UnknownStruct58
@dataclasses.dataclass()
class UnknownStruct285(BaseProperty):
unknown_struct279: UnknownStruct279 = dataclasses.field(default_factory=UnknownStruct279)
unknown_struct58_0xc9045a02: UnknownStruct58 = dataclasses.field(default_factory=UnknownStruct58)
unknown_struct280: UnknownStruct280 = dataclasses.field(default_factory=UnknownStruct280)
unknown_struct58_0xfab2f514: UnknownStruct58 = dataclasses.field(default_factory=UnknownStruct58)
unknown_struct281: UnknownStruct281 = dataclasses.field(default_factory=UnknownStruct281)
unknown_0x7a5e5e73: UnknownStruct281 = dataclasses.field(default_factory=UnknownStruct281)
unknown_struct282: UnknownStruct282 = dataclasses.field(default_factory=UnknownStruct282)
unknown_struct283: UnknownStruct283 = dataclasses.field(default_factory=UnknownStruct283)
unknown_struct284: UnknownStruct284 = dataclasses.field(default_factory=UnknownStruct284)
unknown_0x016768be: UnknownStruct284 = dataclasses.field(default_factory=UnknownStruct284)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\x16\xd2\x06@') # 0x16d20640
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct279.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9\x04Z\x02') # 0xc9045a02
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct58_0xc9045a02.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5\xa3\x1f\xc4') # 0xc5a31fc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct280.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa\xb2\xf5\x14') # 0xfab2f514
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct58_0xfab2f514.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'jUI\xa3') # 0x6a5549a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct281.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'z^^s') # 0x7a5e5e73
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7a5e5e73.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c\xcd\x83\x9f') # 0x63cd839f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct282.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1z\xef\x10') # 0xf17aef10
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct283.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc92\xf0\x84') # 0xc932f084
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct284.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01gh\xbe') # 0x16768be
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x016768be.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_struct279=UnknownStruct279.from_json(data['unknown_struct279']),
unknown_struct58_0xc9045a02=UnknownStruct58.from_json(data['unknown_struct58_0xc9045a02']),
unknown_struct280=UnknownStruct280.from_json(data['unknown_struct280']),
unknown_struct58_0xfab2f514=UnknownStruct58.from_json(data['unknown_struct58_0xfab2f514']),
unknown_struct281=UnknownStruct281.from_json(data['unknown_struct281']),
unknown_0x7a5e5e73=UnknownStruct281.from_json(data['unknown_0x7a5e5e73']),
unknown_struct282=UnknownStruct282.from_json(data['unknown_struct282']),
unknown_struct283=UnknownStruct283.from_json(data['unknown_struct283']),
unknown_struct284=UnknownStruct284.from_json(data['unknown_struct284']),
unknown_0x016768be=UnknownStruct284.from_json(data['unknown_0x016768be']),
)
def to_json(self) -> dict:
return {
'unknown_struct279': self.unknown_struct279.to_json(),
'unknown_struct58_0xc9045a02': self.unknown_struct58_0xc9045a02.to_json(),
'unknown_struct280': self.unknown_struct280.to_json(),
'unknown_struct58_0xfab2f514': self.unknown_struct58_0xfab2f514.to_json(),
'unknown_struct281': self.unknown_struct281.to_json(),
'unknown_0x7a5e5e73': self.unknown_0x7a5e5e73.to_json(),
'unknown_struct282': self.unknown_struct282.to_json(),
'unknown_struct283': self.unknown_struct283.to_json(),
'unknown_struct284': self.unknown_struct284.to_json(),
'unknown_0x016768be': self.unknown_0x016768be.to_json(),
}
def _decode_unknown_struct279(data: typing.BinaryIO, property_size: int):
return UnknownStruct279.from_stream(data, property_size)
def _decode_unknown_struct58_0xc9045a02(data: typing.BinaryIO, property_size: int):
return UnknownStruct58.from_stream(data, property_size)
def _decode_unknown_struct280(data: typing.BinaryIO, property_size: int):
return UnknownStruct280.from_stream(data, property_size)
def _decode_unknown_struct58_0xfab2f514(data: typing.BinaryIO, property_size: int):
return UnknownStruct58.from_stream(data, property_size)
def _decode_unknown_struct281(data: typing.BinaryIO, property_size: int):
return UnknownStruct281.from_stream(data, property_size)
def _decode_unknown_0x7a5e5e73(data: typing.BinaryIO, property_size: int):
return UnknownStruct281.from_stream(data, property_size)
def _decode_unknown_struct282(data: typing.BinaryIO, property_size: int):
return UnknownStruct282.from_stream(data, property_size)
def _decode_unknown_struct283(data: typing.BinaryIO, property_size: int):
return UnknownStruct283.from_stream(data, property_size)
def _decode_unknown_struct284(data: typing.BinaryIO, property_size: int):
return UnknownStruct284.from_stream(data, property_size)
def _decode_unknown_0x016768be(data: typing.BinaryIO, property_size: int):
return UnknownStruct284.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x16d20640: ('unknown_struct279', _decode_unknown_struct279),
0xc9045a02: ('unknown_struct58_0xc9045a02', _decode_unknown_struct58_0xc9045a02),
0xc5a31fc4: ('unknown_struct280', _decode_unknown_struct280),
0xfab2f514: ('unknown_struct58_0xfab2f514', _decode_unknown_struct58_0xfab2f514),
0x6a5549a3: ('unknown_struct281', _decode_unknown_struct281),
0x7a5e5e73: ('unknown_0x7a5e5e73', _decode_unknown_0x7a5e5e73),
0x63cd839f: ('unknown_struct282', _decode_unknown_struct282),
0xf17aef10: ('unknown_struct283', _decode_unknown_struct283),
0xc932f084: ('unknown_struct284', _decode_unknown_struct284),
0x16768be: ('unknown_0x016768be', _decode_unknown_0x016768be),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct285.py | 0.500488 | 0.28946 | UnknownStruct285.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.dkc_returns.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.dkc_returns.archetypes.HealthInfo import HealthInfo
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 PatternedAITypedef(BaseProperty):
mass: float = dataclasses.field(default=150.0)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_wait_time: float = dataclasses.field(default=2.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
collision_radius: float = dataclasses.field(default=1.0)
collision_height: float = dataclasses.field(default=2.0)
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
step_up_height: float = dataclasses.field(default=0.10000000149011612)
step_down_height: float = dataclasses.field(default=0.1599999964237213)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
fsmc_0x1749405b: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
fsmc_0x1b21eeb2: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
path_mesh_index: int = dataclasses.field(default=0)
unknown_0x39a6dec3: float = dataclasses.field(default=5.0)
unknown_0x47de2455: bool = dataclasses.field(default=False)
creature_death_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0xc88ad680: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
caud: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
creature_death_particle_effect_uses_creature_orientation: bool = dataclasses.field(default=True)
ground_pound_slap_detection_radius: float = dataclasses.field(default=5.0)
speed: float = dataclasses.field(default=1.0)
turn_speed: float = dataclasses.field(default=120.0)
unknown_0x6d892893: bool = dataclasses.field(default=True)
detection_range: float = dataclasses.field(default=100.0)
detection_height_range: float = dataclasses.field(default=0.0)
detection_angle: float = dataclasses.field(default=60.0)
min_attack_range: float = dataclasses.field(default=6.0)
max_attack_range: float = dataclasses.field(default=11.0)
average_attack_time: float = dataclasses.field(default=2.0)
attack_time_variation: 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\x1f') # 31 properties
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd7VAn') # 0xd756416e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0\xcd\xc7\xe3') # 0xe0cdc7e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_wait_time))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8aj\xb19') # 0x8a6ab139
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_radius))
data.write(b'0\x11\xb5\xdf') # 0x3011b5df
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_height))
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xd95Vt') # 0xd9355674
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.step_up_height))
data.write(b'\x88\xea\x81\xdb') # 0x88ea81db
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.step_down_height))
data.write(b'\xa2D\xc9\xd8') # 0xa244c9d8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17I@[') # 0x1749405b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fsmc_0x1749405b))
data.write(b'\x1b!\xee\xb2') # 0x1b21eeb2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fsmc_0x1b21eeb2))
data.write(b'\x98\x16\x964') # 0x98169634
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.path_mesh_index))
data.write(b'9\xa6\xde\xc3') # 0x39a6dec3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x39a6dec3))
data.write(b'G\xde$U') # 0x47de2455
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x47de2455))
data.write(b'\xdf\xe7H\x95') # 0xdfe74895
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.creature_death_particle_effect))
data.write(b'\xc8\x8a\xd6\x80') # 0xc88ad680
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xc88ad680))
data.write(b'd\xc2&g') # 0x64c22667
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caud))
data.write(b'\xfd\x8a\x96\x92') # 0xfd8a9692
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.creature_death_particle_effect_uses_creature_orientation))
data.write(b'\xe0dD\x02') # 0xe0644402
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_pound_slap_detection_radius))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'\x02\x0cx\xbb') # 0x20c78bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed))
data.write(b'm\x89(\x93') # 0x6d892893
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x6d892893))
data.write(b'\x8d\xb7~\xe4') # 0x8db77ee4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_range))
data.write(b'Q?\x04\xb8') # 0x513f04b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_height_range))
data.write(b'\x83\xdf\xc4\x0f') # 0x83dfc40f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_angle))
data.write(b'XCI\x16') # 0x58434916
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attack_range))
data.write(b'\xffw\xc9o') # 0xff77c96f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_range))
data.write(b'\xb0\xcf\xe0\x15') # 0xb0cfe015
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.average_attack_time))
data.write(b'\xc8\x0e2\x9b') # 0xc80e329b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_time_variation))
@classmethod
def from_json(cls, data: dict):
return cls(
mass=data['mass'],
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
contact_damage=DamageInfo.from_json(data['contact_damage']),
damage_wait_time=data['damage_wait_time'],
health=HealthInfo.from_json(data['health']),
collision_radius=data['collision_radius'],
collision_height=data['collision_height'],
collision_offset=Vector.from_json(data['collision_offset']),
step_up_height=data['step_up_height'],
step_down_height=data['step_down_height'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
fsmc_0x1749405b=data['fsmc_0x1749405b'],
fsmc_0x1b21eeb2=data['fsmc_0x1b21eeb2'],
path_mesh_index=data['path_mesh_index'],
unknown_0x39a6dec3=data['unknown_0x39a6dec3'],
unknown_0x47de2455=data['unknown_0x47de2455'],
creature_death_particle_effect=data['creature_death_particle_effect'],
unknown_0xc88ad680=data['unknown_0xc88ad680'],
caud=data['caud'],
creature_death_particle_effect_uses_creature_orientation=data['creature_death_particle_effect_uses_creature_orientation'],
ground_pound_slap_detection_radius=data['ground_pound_slap_detection_radius'],
speed=data['speed'],
turn_speed=data['turn_speed'],
unknown_0x6d892893=data['unknown_0x6d892893'],
detection_range=data['detection_range'],
detection_height_range=data['detection_height_range'],
detection_angle=data['detection_angle'],
min_attack_range=data['min_attack_range'],
max_attack_range=data['max_attack_range'],
average_attack_time=data['average_attack_time'],
attack_time_variation=data['attack_time_variation'],
)
def to_json(self) -> dict:
return {
'mass': self.mass,
'vulnerability': self.vulnerability.to_json(),
'contact_damage': self.contact_damage.to_json(),
'damage_wait_time': self.damage_wait_time,
'health': self.health.to_json(),
'collision_radius': self.collision_radius,
'collision_height': self.collision_height,
'collision_offset': self.collision_offset.to_json(),
'step_up_height': self.step_up_height,
'step_down_height': self.step_down_height,
'character_animation_information': self.character_animation_information.to_json(),
'fsmc_0x1749405b': self.fsmc_0x1749405b,
'fsmc_0x1b21eeb2': self.fsmc_0x1b21eeb2,
'path_mesh_index': self.path_mesh_index,
'unknown_0x39a6dec3': self.unknown_0x39a6dec3,
'unknown_0x47de2455': self.unknown_0x47de2455,
'creature_death_particle_effect': self.creature_death_particle_effect,
'unknown_0xc88ad680': self.unknown_0xc88ad680,
'caud': self.caud,
'creature_death_particle_effect_uses_creature_orientation': self.creature_death_particle_effect_uses_creature_orientation,
'ground_pound_slap_detection_radius': self.ground_pound_slap_detection_radius,
'speed': self.speed,
'turn_speed': self.turn_speed,
'unknown_0x6d892893': self.unknown_0x6d892893,
'detection_range': self.detection_range,
'detection_height_range': self.detection_height_range,
'detection_angle': self.detection_angle,
'min_attack_range': self.min_attack_range,
'max_attack_range': self.max_attack_range,
'average_attack_time': self.average_attack_time,
'attack_time_variation': self.attack_time_variation,
}
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_contact_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_damage_wait_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_collision_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_step_up_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_step_down_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_fsmc_0x1749405b(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_fsmc_0x1b21eeb2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_path_mesh_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x39a6dec3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x47de2455(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_creature_death_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xc88ad680(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_creature_death_particle_effect_uses_creature_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ground_pound_slap_detection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6d892893(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_detection_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_height_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_average_attack_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_time_variation(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]]] = {
0x75dbb375: ('mass', _decode_mass),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xd756416e: ('contact_damage', _decode_contact_damage),
0xe0cdc7e3: ('damage_wait_time', _decode_damage_wait_time),
0xcf90d15e: ('health', _decode_health),
0x8a6ab139: ('collision_radius', _decode_collision_radius),
0x3011b5df: ('collision_height', _decode_collision_height),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xd9355674: ('step_up_height', _decode_step_up_height),
0x88ea81db: ('step_down_height', _decode_step_down_height),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x1749405b: ('fsmc_0x1749405b', _decode_fsmc_0x1749405b),
0x1b21eeb2: ('fsmc_0x1b21eeb2', _decode_fsmc_0x1b21eeb2),
0x98169634: ('path_mesh_index', _decode_path_mesh_index),
0x39a6dec3: ('unknown_0x39a6dec3', _decode_unknown_0x39a6dec3),
0x47de2455: ('unknown_0x47de2455', _decode_unknown_0x47de2455),
0xdfe74895: ('creature_death_particle_effect', _decode_creature_death_particle_effect),
0xc88ad680: ('unknown_0xc88ad680', _decode_unknown_0xc88ad680),
0x64c22667: ('caud', _decode_caud),
0xfd8a9692: ('creature_death_particle_effect_uses_creature_orientation', _decode_creature_death_particle_effect_uses_creature_orientation),
0xe0644402: ('ground_pound_slap_detection_radius', _decode_ground_pound_slap_detection_radius),
0x6392404e: ('speed', _decode_speed),
0x20c78bb: ('turn_speed', _decode_turn_speed),
0x6d892893: ('unknown_0x6d892893', _decode_unknown_0x6d892893),
0x8db77ee4: ('detection_range', _decode_detection_range),
0x513f04b8: ('detection_height_range', _decode_detection_height_range),
0x83dfc40f: ('detection_angle', _decode_detection_angle),
0x58434916: ('min_attack_range', _decode_min_attack_range),
0xff77c96f: ('max_attack_range', _decode_max_attack_range),
0xb0cfe015: ('average_attack_time', _decode_average_attack_time),
0xc80e329b: ('attack_time_variation', _decode_attack_time_variation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PatternedAITypedef.py | 0.607663 | 0.262514 | PatternedAITypedef.py | 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.OffsetInterpolant import OffsetInterpolant
@dataclasses.dataclass()
class OffsetPosition(BaseProperty):
offset_type: enums.OffsetType = dataclasses.field(default=enums.OffsetType.Unknown1)
offset: OffsetInterpolant = dataclasses.field(default_factory=OffsetInterpolant)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'p\xc7\x8c>') # 0x70c78c3e
data.write(b'\x00\x04') # size
self.offset_type.to_stream(data)
data.write(b'7i\xa2\t') # 0x3769a209
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
offset_type=enums.OffsetType.from_json(data['offset_type']),
offset=OffsetInterpolant.from_json(data['offset']),
)
def to_json(self) -> dict:
return {
'offset_type': self.offset_type.to_json(),
'offset': self.offset.to_json(),
}
def _decode_offset_type(data: typing.BinaryIO, property_size: int):
return enums.OffsetType.from_stream(data)
def _decode_offset(data: typing.BinaryIO, property_size: int):
return OffsetInterpolant.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x70c78c3e: ('offset_type', _decode_offset_type),
0x3769a209: ('offset', _decode_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/OffsetPosition.py | 0.654011 | 0.283188 | OffsetPosition.py | 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 UnknownStruct284(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'\x8aX\xa7\xf8') # 0x8a58a7f8
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 = (0x8a58a7f8)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct284]:
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 UnknownStruct284(
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]]] = {
0x8a58a7f8: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct284.py | 0.621426 | 0.285329 | UnknownStruct284.py | 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 SurroundPan(BaseProperty):
pan: float = dataclasses.field(default=0.0)
surround_pan: 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\x02') # 2 properties
data.write(b'\xdfCS\xa3') # 0xdf4353a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan))
data.write(b'H+\x88\xaa') # 0x482b88aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.surround_pan))
@classmethod
def from_json(cls, data: dict):
return cls(
pan=data['pan'],
surround_pan=data['surround_pan'],
)
def to_json(self) -> dict:
return {
'pan': self.pan,
'surround_pan': self.surround_pan,
}
_FAST_FORMAT = None
_FAST_IDS = (0xdf4353a3, 0x482b88aa)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SurroundPan]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return SurroundPan(
dec[2],
dec[5],
)
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_surround_pan(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]]] = {
0xdf4353a3: ('pan', _decode_pan),
0x482b88aa: ('surround_pan', _decode_surround_pan),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SurroundPan.py | 0.660063 | 0.320702 | SurroundPan.py | 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 UnknownStruct178(BaseProperty):
gui_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
unknown_0x1dd553a2: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0x765f0301: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 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'\x1d\xd5S\xa2') # 0x1dd553a2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x1dd553a2))
data.write(b'v_\x03\x01') # 0x765f0301
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x765f0301))
@classmethod
def from_json(cls, data: dict):
return cls(
gui_frame=data['gui_frame'],
unknown_0x1dd553a2=data['unknown_0x1dd553a2'],
unknown_0x765f0301=data['unknown_0x765f0301'],
)
def to_json(self) -> dict:
return {
'gui_frame': self.gui_frame,
'unknown_0x1dd553a2': self.unknown_0x1dd553a2,
'unknown_0x765f0301': self.unknown_0x765f0301,
}
_FAST_FORMAT = None
_FAST_IDS = (0x806052cb, 0x1dd553a2, 0x765f0301)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct178]:
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 UnknownStruct178(
dec[2],
dec[5],
dec[8],
)
def _decode_gui_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x1dd553a2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x765f0301(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x806052cb: ('gui_frame', _decode_gui_frame),
0x1dd553a2: ('unknown_0x1dd553a2', _decode_unknown_0x1dd553a2),
0x765f0301: ('unknown_0x765f0301', _decode_unknown_0x765f0301),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct178.py | 0.590189 | 0.247965 | UnknownStruct178.py | 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 CameraTracking(BaseProperty):
tracking_type: enums.TrackingType = dataclasses.field(default=enums.TrackingType.Unknown2)
tracking_axis: enums.TrackingAxis = dataclasses.field(default=enums.TrackingAxis.Unknown1)
update_line_of_sight: bool = dataclasses.field(default=False)
use_bounds_for_non_players: bool = dataclasses.field(default=False)
ignore_players_in_bounds: bool = dataclasses.field(default=False)
attack_bounce_considered_on_ground: 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\x06') # 6 properties
data.write(b'[\xfe\xd7\xdb') # 0x5bfed7db
data.write(b'\x00\x04') # size
self.tracking_type.to_stream(data)
data.write(b'\x02\xab\xd2Q') # 0x2abd251
data.write(b'\x00\x04') # size
self.tracking_axis.to_stream(data)
data.write(b'\xbb\xb4\x89\xd0') # 0xbbb489d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.update_line_of_sight))
data.write(b'~\xbd\xd6l') # 0x7ebdd66c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_bounds_for_non_players))
data.write(b'\x8f\xa9h\x9c') # 0x8fa9689c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_players_in_bounds))
data.write(b'\xe2e\xedV') # 0xe265ed56
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.attack_bounce_considered_on_ground))
@classmethod
def from_json(cls, data: dict):
return cls(
tracking_type=enums.TrackingType.from_json(data['tracking_type']),
tracking_axis=enums.TrackingAxis.from_json(data['tracking_axis']),
update_line_of_sight=data['update_line_of_sight'],
use_bounds_for_non_players=data['use_bounds_for_non_players'],
ignore_players_in_bounds=data['ignore_players_in_bounds'],
attack_bounce_considered_on_ground=data['attack_bounce_considered_on_ground'],
)
def to_json(self) -> dict:
return {
'tracking_type': self.tracking_type.to_json(),
'tracking_axis': self.tracking_axis.to_json(),
'update_line_of_sight': self.update_line_of_sight,
'use_bounds_for_non_players': self.use_bounds_for_non_players,
'ignore_players_in_bounds': self.ignore_players_in_bounds,
'attack_bounce_considered_on_ground': self.attack_bounce_considered_on_ground,
}
_FAST_FORMAT = None
_FAST_IDS = (0x5bfed7db, 0x2abd251, 0xbbb489d0, 0x7ebdd66c, 0x8fa9689c, 0xe265ed56)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraTracking]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHLLH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(48))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return CameraTracking(
enums.TrackingType(dec[2]),
enums.TrackingAxis(dec[5]),
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_tracking_type(data: typing.BinaryIO, property_size: int):
return enums.TrackingType.from_stream(data)
def _decode_tracking_axis(data: typing.BinaryIO, property_size: int):
return enums.TrackingAxis.from_stream(data)
def _decode_update_line_of_sight(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_bounds_for_non_players(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_players_in_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_attack_bounce_considered_on_ground(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]]] = {
0x5bfed7db: ('tracking_type', _decode_tracking_type),
0x2abd251: ('tracking_axis', _decode_tracking_axis),
0xbbb489d0: ('update_line_of_sight', _decode_update_line_of_sight),
0x7ebdd66c: ('use_bounds_for_non_players', _decode_use_bounds_for_non_players),
0x8fa9689c: ('ignore_players_in_bounds', _decode_ignore_players_in_bounds),
0xe265ed56: ('attack_bounce_considered_on_ground', _decode_attack_bounce_considered_on_ground),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CameraTracking.py | 0.640861 | 0.291611 | CameraTracking.py | 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.UnknownStruct142 import UnknownStruct142
@dataclasses.dataclass()
class UnknownStruct143(BaseProperty):
unknown: int = dataclasses.field(default=1138461727) # Choice
timer: float = dataclasses.field(default=0.0)
unknown_struct142: UnknownStruct142 = dataclasses.field(default_factory=UnknownStruct142)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'c\xbe R') # 0x63be2052
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown))
data.write(b'\x87GU.') # 0x8747552e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.timer))
data.write(b'q\xe9\xd1\xa1') # 0x71e9d1a1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct142.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'],
timer=data['timer'],
unknown_struct142=UnknownStruct142.from_json(data['unknown_struct142']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'timer': self.timer,
'unknown_struct142': self.unknown_struct142.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct142(data: typing.BinaryIO, property_size: int):
return UnknownStruct142.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x63be2052: ('unknown', _decode_unknown),
0x8747552e: ('timer', _decode_timer),
0x71e9d1a1: ('unknown_struct142', _decode_unknown_struct142),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct143.py | 0.629205 | 0.299131 | UnknownStruct143.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct299(BaseProperty):
enabled: bool = dataclasses.field(default=False)
color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b")\xc7}'") # 0x29c77d27
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enabled))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
enabled=data['enabled'],
color=Color.from_json(data['color']),
)
def to_json(self) -> dict:
return {
'enabled': self.enabled,
'color': self.color.to_json(),
}
def _decode_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_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]]] = {
0x29c77d27: ('enabled', _decode_enabled),
0x37c7d09d: ('color', _decode_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct299.py | 0.69285 | 0.280038 | UnknownStruct299.py | 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.UnknownStruct232 import UnknownStruct232
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct233 import UnknownStruct233
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct234 import UnknownStruct234
@dataclasses.dataclass()
class UnknownStruct235(BaseProperty):
first_attack_delay: float = dataclasses.field(default=2.0)
unknown_struct232: UnknownStruct232 = dataclasses.field(default_factory=UnknownStruct232)
unknown_struct233: UnknownStruct233 = dataclasses.field(default_factory=UnknownStruct233)
unknown_struct234: UnknownStruct234 = dataclasses.field(default_factory=UnknownStruct234)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'[\x94DK') # 0x5b94444b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.first_attack_delay))
data.write(b'\xfeMd\x82') # 0xfe4d6482
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct232.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\xffV\x13') # 0x73ff5613
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct233.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7\x15\x0eZ') # 0xc7150e5a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct234.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(
first_attack_delay=data['first_attack_delay'],
unknown_struct232=UnknownStruct232.from_json(data['unknown_struct232']),
unknown_struct233=UnknownStruct233.from_json(data['unknown_struct233']),
unknown_struct234=UnknownStruct234.from_json(data['unknown_struct234']),
)
def to_json(self) -> dict:
return {
'first_attack_delay': self.first_attack_delay,
'unknown_struct232': self.unknown_struct232.to_json(),
'unknown_struct233': self.unknown_struct233.to_json(),
'unknown_struct234': self.unknown_struct234.to_json(),
}
def _decode_first_attack_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct232(data: typing.BinaryIO, property_size: int):
return UnknownStruct232.from_stream(data, property_size)
def _decode_unknown_struct233(data: typing.BinaryIO, property_size: int):
return UnknownStruct233.from_stream(data, property_size)
def _decode_unknown_struct234(data: typing.BinaryIO, property_size: int):
return UnknownStruct234.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5b94444b: ('first_attack_delay', _decode_first_attack_delay),
0xfe4d6482: ('unknown_struct232', _decode_unknown_struct232),
0x73ff5613: ('unknown_struct233', _decode_unknown_struct233),
0xc7150e5a: ('unknown_struct234', _decode_unknown_struct234),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct235.py | 0.657209 | 0.292551 | UnknownStruct235.py | 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 KongGroundPoundData(BaseProperty):
ground_pound_box_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=30.0, y=30.0, z=30.0))
min_delay_between_slaps: float = dataclasses.field(default=0.10000000149011612)
delay_between_same_hand_slaps: float = dataclasses.field(default=1.0)
delay_horizontal_movement_after_slap: float = dataclasses.field(default=1.0)
delay_jumping_after_slap: 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]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'\xdb\xb1>\x19') # 0xdbb13e19
data.write(b'\x00\x0c') # size
self.ground_pound_box_scale.to_stream(data)
data.write(b'E\x8f{\x04') # 0x458f7b04
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_delay_between_slaps))
data.write(b'\xa6\xa1\xcd\x8f') # 0xa6a1cd8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_between_same_hand_slaps))
data.write(b'=#>S') # 0x3d233e53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_horizontal_movement_after_slap))
data.write(b'\xa4\xab\x00\xa8') # 0xa4ab00a8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_jumping_after_slap))
@classmethod
def from_json(cls, data: dict):
return cls(
ground_pound_box_scale=Vector.from_json(data['ground_pound_box_scale']),
min_delay_between_slaps=data['min_delay_between_slaps'],
delay_between_same_hand_slaps=data['delay_between_same_hand_slaps'],
delay_horizontal_movement_after_slap=data['delay_horizontal_movement_after_slap'],
delay_jumping_after_slap=data['delay_jumping_after_slap'],
)
def to_json(self) -> dict:
return {
'ground_pound_box_scale': self.ground_pound_box_scale.to_json(),
'min_delay_between_slaps': self.min_delay_between_slaps,
'delay_between_same_hand_slaps': self.delay_between_same_hand_slaps,
'delay_horizontal_movement_after_slap': self.delay_horizontal_movement_after_slap,
'delay_jumping_after_slap': self.delay_jumping_after_slap,
}
def _decode_ground_pound_box_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_min_delay_between_slaps(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_between_same_hand_slaps(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_horizontal_movement_after_slap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_jumping_after_slap(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]]] = {
0xdbb13e19: ('ground_pound_box_scale', _decode_ground_pound_box_scale),
0x458f7b04: ('min_delay_between_slaps', _decode_min_delay_between_slaps),
0xa6a1cd8f: ('delay_between_same_hand_slaps', _decode_delay_between_same_hand_slaps),
0x3d233e53: ('delay_horizontal_movement_after_slap', _decode_delay_horizontal_movement_after_slap),
0xa4ab00a8: ('delay_jumping_after_slap', _decode_delay_jumping_after_slap),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/KongGroundPoundData.py | 0.702428 | 0.298236 | KongGroundPoundData.py | 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 UnknownStruct17(BaseProperty):
transform: enums.Transform = dataclasses.field(default=enums.Transform.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'\x05[\x82\x91') # 0x55b8291
data.write(b'\x00\x04') # size
self.transform.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
transform=enums.Transform.from_json(data['transform']),
)
def to_json(self) -> dict:
return {
'transform': self.transform.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x55b8291)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct17]:
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 UnknownStruct17(
enums.Transform(dec[2]),
)
def _decode_transform(data: typing.BinaryIO, property_size: int):
return enums.Transform.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x55b8291: ('transform', _decode_transform),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct17.py | 0.675336 | 0.317373 | UnknownStruct17.py | 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 VisControl(BaseProperty):
number_of_strings: int = dataclasses.field(default=0)
string1: str = dataclasses.field(default='')
string2: str = dataclasses.field(default='')
string3: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xdd\xec\xee\x96') # 0xddecee96
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_strings))
data.write(b'\x87\xdc\xd2\xb9') # 0x87dcd2b9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.string1.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'\xb64\xc8$') # 0xb634c824
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.string2.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'\x10C\xc3\x90') # 0x1043c390
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.string3.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(
number_of_strings=data['number_of_strings'],
string1=data['string1'],
string2=data['string2'],
string3=data['string3'],
)
def to_json(self) -> dict:
return {
'number_of_strings': self.number_of_strings,
'string1': self.string1,
'string2': self.string2,
'string3': self.string3,
}
def _decode_number_of_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string1(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_string2(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_string3(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]]] = {
0xddecee96: ('number_of_strings', _decode_number_of_strings),
0x87dcd2b9: ('string1', _decode_string1),
0xb634c824: ('string2', _decode_string2),
0x1043c390: ('string3', _decode_string3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VisControl.py | 0.574634 | 0.33928 | VisControl.py | 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 UnknownStruct230(BaseProperty):
unknown_0x43bc661c: bool = dataclasses.field(default=False)
allow_swipe: bool = dataclasses.field(default=False)
unknown_0xe10e94ec: float = dataclasses.field(default=1.0)
unknown_0x84b3080b: str = dataclasses.field(default='')
unknown_0x69170884: 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\x05') # 5 properties
data.write(b'C\xbcf\x1c') # 0x43bc661c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x43bc661c))
data.write(b'A\x0b\xde\xf2') # 0x410bdef2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_swipe))
data.write(b'\xe1\x0e\x94\xec') # 0xe10e94ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe10e94ec))
data.write(b'\x84\xb3\x08\x0b') # 0x84b3080b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x84b3080b.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'i\x17\x08\x84') # 0x69170884
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x69170884.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x43bc661c=data['unknown_0x43bc661c'],
allow_swipe=data['allow_swipe'],
unknown_0xe10e94ec=data['unknown_0xe10e94ec'],
unknown_0x84b3080b=data['unknown_0x84b3080b'],
unknown_0x69170884=data['unknown_0x69170884'],
)
def to_json(self) -> dict:
return {
'unknown_0x43bc661c': self.unknown_0x43bc661c,
'allow_swipe': self.allow_swipe,
'unknown_0xe10e94ec': self.unknown_0xe10e94ec,
'unknown_0x84b3080b': self.unknown_0x84b3080b,
'unknown_0x69170884': self.unknown_0x69170884,
}
def _decode_unknown_0x43bc661c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_swipe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe10e94ec(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x84b3080b(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x69170884(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]]] = {
0x43bc661c: ('unknown_0x43bc661c', _decode_unknown_0x43bc661c),
0x410bdef2: ('allow_swipe', _decode_allow_swipe),
0xe10e94ec: ('unknown_0xe10e94ec', _decode_unknown_0xe10e94ec),
0x84b3080b: ('unknown_0x84b3080b', _decode_unknown_0x84b3080b),
0x69170884: ('unknown_0x69170884', _decode_unknown_0x69170884),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct230.py | 0.577853 | 0.314853 | UnknownStruct230.py | 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 RobotChickenStructA(BaseProperty):
unknown_0x86982e06: int = dataclasses.field(default=5)
grid_dist_min: int = dataclasses.field(default=4)
grid_dist_max: int = dataclasses.field(default=7)
unknown_0x3c182e6d: int = dataclasses.field(default=33)
unknown_0x5bdf89c0: int = dataclasses.field(default=33)
unknown_0xd8828f28: int = dataclasses.field(default=0)
unknown_0xd387b254: 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\x07') # 7 properties
data.write(b'\x86\x98.\x06') # 0x86982e06
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x86982e06))
data.write(b'\xcf\n\xdc\x96') # 0xcf0adc96
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.grid_dist_min))
data.write(b'\x8a\x08\x9f\x14') # 0x8a089f14
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.grid_dist_max))
data.write(b'<\x18.m') # 0x3c182e6d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3c182e6d))
data.write(b'[\xdf\x89\xc0') # 0x5bdf89c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x5bdf89c0))
data.write(b'\xd8\x82\x8f(') # 0xd8828f28
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd8828f28))
data.write(b'\xd3\x87\xb2T') # 0xd387b254
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd387b254))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x86982e06=data['unknown_0x86982e06'],
grid_dist_min=data['grid_dist_min'],
grid_dist_max=data['grid_dist_max'],
unknown_0x3c182e6d=data['unknown_0x3c182e6d'],
unknown_0x5bdf89c0=data['unknown_0x5bdf89c0'],
unknown_0xd8828f28=data['unknown_0xd8828f28'],
unknown_0xd387b254=data['unknown_0xd387b254'],
)
def to_json(self) -> dict:
return {
'unknown_0x86982e06': self.unknown_0x86982e06,
'grid_dist_min': self.grid_dist_min,
'grid_dist_max': self.grid_dist_max,
'unknown_0x3c182e6d': self.unknown_0x3c182e6d,
'unknown_0x5bdf89c0': self.unknown_0x5bdf89c0,
'unknown_0xd8828f28': self.unknown_0xd8828f28,
'unknown_0xd387b254': self.unknown_0xd387b254,
}
_FAST_FORMAT = None
_FAST_IDS = (0x86982e06, 0xcf0adc96, 0x8a089f14, 0x3c182e6d, 0x5bdf89c0, 0xd8828f28, 0xd387b254)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RobotChickenStructA]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHlLHlLHlLHlLHlLHlLHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(70))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return RobotChickenStructA(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_unknown_0x86982e06(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_grid_dist_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_grid_dist_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x3c182e6d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x5bdf89c0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd8828f28(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd387b254(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]]] = {
0x86982e06: ('unknown_0x86982e06', _decode_unknown_0x86982e06),
0xcf0adc96: ('grid_dist_min', _decode_grid_dist_min),
0x8a089f14: ('grid_dist_max', _decode_grid_dist_max),
0x3c182e6d: ('unknown_0x3c182e6d', _decode_unknown_0x3c182e6d),
0x5bdf89c0: ('unknown_0x5bdf89c0', _decode_unknown_0x5bdf89c0),
0xd8828f28: ('unknown_0xd8828f28', _decode_unknown_0xd8828f28),
0xd387b254: ('unknown_0xd387b254', _decode_unknown_0xd387b254),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RobotChickenStructA.py | 0.57081 | 0.290207 | RobotChickenStructA.py | 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 UnknownStruct188(BaseProperty):
unknown_0xe84a887b: float = dataclasses.field(default=1.0)
unknown_0x8a58a7f8: int = dataclasses.field(default=2)
unknown_0x1d18ec45: bool = dataclasses.field(default=False)
stun_duration: float = dataclasses.field(default=2.0)
unknown_0x634415f0: float = dataclasses.field(default=1.0)
unknown_0x82090854: float = dataclasses.field(default=0.5)
unknown_0x0c7f57a5: float = dataclasses.field(default=0.5)
unknown_0x1a75dce7: float = dataclasses.field(default=0.5)
unknown_0x89c8bb60: float = dataclasses.field(default=4.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 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'\x1d\x18\xecE') # 0x1d18ec45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x1d18ec45))
data.write(b'-\x8d\xb3\x1d') # 0x2d8db31d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_duration))
data.write(b'cD\x15\xf0') # 0x634415f0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x634415f0))
data.write(b'\x82\t\x08T') # 0x82090854
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x82090854))
data.write(b'\x0c\x7fW\xa5') # 0xc7f57a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0c7f57a5))
data.write(b'\x1au\xdc\xe7') # 0x1a75dce7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1a75dce7))
data.write(b'\x89\xc8\xbb`') # 0x89c8bb60
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x89c8bb60))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xe84a887b=data['unknown_0xe84a887b'],
unknown_0x8a58a7f8=data['unknown_0x8a58a7f8'],
unknown_0x1d18ec45=data['unknown_0x1d18ec45'],
stun_duration=data['stun_duration'],
unknown_0x634415f0=data['unknown_0x634415f0'],
unknown_0x82090854=data['unknown_0x82090854'],
unknown_0x0c7f57a5=data['unknown_0x0c7f57a5'],
unknown_0x1a75dce7=data['unknown_0x1a75dce7'],
unknown_0x89c8bb60=data['unknown_0x89c8bb60'],
)
def to_json(self) -> dict:
return {
'unknown_0xe84a887b': self.unknown_0xe84a887b,
'unknown_0x8a58a7f8': self.unknown_0x8a58a7f8,
'unknown_0x1d18ec45': self.unknown_0x1d18ec45,
'stun_duration': self.stun_duration,
'unknown_0x634415f0': self.unknown_0x634415f0,
'unknown_0x82090854': self.unknown_0x82090854,
'unknown_0x0c7f57a5': self.unknown_0x0c7f57a5,
'unknown_0x1a75dce7': self.unknown_0x1a75dce7,
'unknown_0x89c8bb60': self.unknown_0x89c8bb60,
}
_FAST_FORMAT = None
_FAST_IDS = (0xe84a887b, 0x8a58a7f8, 0x1d18ec45, 0x2d8db31d, 0x634415f0, 0x82090854, 0xc7f57a5, 0x1a75dce7, 0x89c8bb60)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct188]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHlLH?LHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(87))
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 UnknownStruct188(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
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_unknown_0x1d18ec45(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_stun_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x634415f0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x82090854(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0c7f57a5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1a75dce7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x89c8bb60(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),
0x1d18ec45: ('unknown_0x1d18ec45', _decode_unknown_0x1d18ec45),
0x2d8db31d: ('stun_duration', _decode_stun_duration),
0x634415f0: ('unknown_0x634415f0', _decode_unknown_0x634415f0),
0x82090854: ('unknown_0x82090854', _decode_unknown_0x82090854),
0xc7f57a5: ('unknown_0x0c7f57a5', _decode_unknown_0x0c7f57a5),
0x1a75dce7: ('unknown_0x1a75dce7', _decode_unknown_0x1a75dce7),
0x89c8bb60: ('unknown_0x89c8bb60', _decode_unknown_0x89c8bb60),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct188.py | 0.635901 | 0.243766 | UnknownStruct188.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.MaterialType import MaterialType
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MaterialSoundPair(BaseProperty):
material: MaterialType = dataclasses.field(default_factory=MaterialType)
sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xd7.\t\xe1') # 0xd72e09e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.material.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa5]\xac\xf6') # 0xa55dacf6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound))
@classmethod
def from_json(cls, data: dict):
return cls(
material=MaterialType.from_json(data['material']),
sound=data['sound'],
)
def to_json(self) -> dict:
return {
'material': self.material.to_json(),
'sound': self.sound,
}
def _decode_material(data: typing.BinaryIO, property_size: int):
return MaterialType.from_stream(data, property_size)
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd72e09e1: ('material', _decode_material),
0xa55dacf6: ('sound', _decode_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/MaterialSoundPair.py | 0.607197 | 0.251809 | MaterialSoundPair.py | 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 UnknownStruct72(BaseProperty):
min_behavior_time: float = dataclasses.field(default=0.5)
unknown_0xf465a51b: bool = dataclasses.field(default=True)
min_cling_time: float = dataclasses.field(default=0.5)
unknown_0xe010dc0f: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xad\x12.]') # 0xad122e5d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_behavior_time))
data.write(b'\xf4e\xa5\x1b') # 0xf465a51b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf465a51b))
data.write(b'B\xa9\xe2\xe4') # 0x42a9e2e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_cling_time))
data.write(b'\xe0\x10\xdc\x0f') # 0xe010dc0f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe010dc0f))
@classmethod
def from_json(cls, data: dict):
return cls(
min_behavior_time=data['min_behavior_time'],
unknown_0xf465a51b=data['unknown_0xf465a51b'],
min_cling_time=data['min_cling_time'],
unknown_0xe010dc0f=data['unknown_0xe010dc0f'],
)
def to_json(self) -> dict:
return {
'min_behavior_time': self.min_behavior_time,
'unknown_0xf465a51b': self.unknown_0xf465a51b,
'min_cling_time': self.min_cling_time,
'unknown_0xe010dc0f': self.unknown_0xe010dc0f,
}
_FAST_FORMAT = None
_FAST_IDS = (0xad122e5d, 0xf465a51b, 0x42a9e2e4, 0xe010dc0f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct72]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(37))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct72(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_min_behavior_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf465a51b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_min_cling_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe010dc0f(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]]] = {
0xad122e5d: ('min_behavior_time', _decode_min_behavior_time),
0xf465a51b: ('unknown_0xf465a51b', _decode_unknown_0xf465a51b),
0x42a9e2e4: ('min_cling_time', _decode_min_cling_time),
0xe010dc0f: ('unknown_0xe010dc0f', _decode_unknown_0xe010dc0f),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct72.py | 0.611382 | 0.306261 | UnknownStruct72.py | 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 UnknownStruct69(BaseProperty):
vertical_offset: float = dataclasses.field(default=3.0)
unknown_0xc241c65a: float = dataclasses.field(default=1.0)
look_right_distance: float = dataclasses.field(default=14.0)
look_left_distance: float = dataclasses.field(default=11.0)
massive_height_distance: float = dataclasses.field(default=5.5)
large_height_distance: float = dataclasses.field(default=2.5)
small_height_distance: float = dataclasses.field(default=0.75)
extra_drop_distance: float = dataclasses.field(default=2.0)
max_platform_distance: float = dataclasses.field(default=6.099999904632568)
unknown_0x935dfcfa: bool = dataclasses.field(default=True)
unknown_0xf2502cd2: float = dataclasses.field(default=1.100000023841858)
unknown_0xf298dcf0: bool = dataclasses.field(default=True)
unknown_0x84b467f0: float = dataclasses.field(default=0.10000000149011612)
unknown_0x1b39c9ab: 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\x0e') # 14 properties
data.write(b'\xb6\x17JN') # 0xb6174a4e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vertical_offset))
data.write(b'\xc2A\xc6Z') # 0xc241c65a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc241c65a))
data.write(b'\xcf\xf7\x10\xd0') # 0xcff710d0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_right_distance))
data.write(b'7\xf0G\x00') # 0x37f04700
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_left_distance))
data.write(b'\xc7\xd1\x1b4') # 0xc7d11b34
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.massive_height_distance))
data.write(b'J\xb0\xdf\x83') # 0x4ab0df83
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.large_height_distance))
data.write(b'\xe0\xf4\xc8\xa2') # 0xe0f4c8a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.small_height_distance))
data.write(b'\xe7\x87\x9b\x05') # 0xe7879b05
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.extra_drop_distance))
data.write(b'v\xdf\x85c') # 0x76df8563
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_platform_distance))
data.write(b'\x93]\xfc\xfa') # 0x935dfcfa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x935dfcfa))
data.write(b'\xf2P,\xd2') # 0xf2502cd2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf2502cd2))
data.write(b'\xf2\x98\xdc\xf0') # 0xf298dcf0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf298dcf0))
data.write(b'\x84\xb4g\xf0') # 0x84b467f0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x84b467f0))
data.write(b'\x1b9\xc9\xab') # 0x1b39c9ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1b39c9ab))
@classmethod
def from_json(cls, data: dict):
return cls(
vertical_offset=data['vertical_offset'],
unknown_0xc241c65a=data['unknown_0xc241c65a'],
look_right_distance=data['look_right_distance'],
look_left_distance=data['look_left_distance'],
massive_height_distance=data['massive_height_distance'],
large_height_distance=data['large_height_distance'],
small_height_distance=data['small_height_distance'],
extra_drop_distance=data['extra_drop_distance'],
max_platform_distance=data['max_platform_distance'],
unknown_0x935dfcfa=data['unknown_0x935dfcfa'],
unknown_0xf2502cd2=data['unknown_0xf2502cd2'],
unknown_0xf298dcf0=data['unknown_0xf298dcf0'],
unknown_0x84b467f0=data['unknown_0x84b467f0'],
unknown_0x1b39c9ab=data['unknown_0x1b39c9ab'],
)
def to_json(self) -> dict:
return {
'vertical_offset': self.vertical_offset,
'unknown_0xc241c65a': self.unknown_0xc241c65a,
'look_right_distance': self.look_right_distance,
'look_left_distance': self.look_left_distance,
'massive_height_distance': self.massive_height_distance,
'large_height_distance': self.large_height_distance,
'small_height_distance': self.small_height_distance,
'extra_drop_distance': self.extra_drop_distance,
'max_platform_distance': self.max_platform_distance,
'unknown_0x935dfcfa': self.unknown_0x935dfcfa,
'unknown_0xf2502cd2': self.unknown_0xf2502cd2,
'unknown_0xf298dcf0': self.unknown_0xf298dcf0,
'unknown_0x84b467f0': self.unknown_0x84b467f0,
'unknown_0x1b39c9ab': self.unknown_0x1b39c9ab,
}
_FAST_FORMAT = None
_FAST_IDS = (0xb6174a4e, 0xc241c65a, 0xcff710d0, 0x37f04700, 0xc7d11b34, 0x4ab0df83, 0xe0f4c8a2, 0xe7879b05, 0x76df8563, 0x935dfcfa, 0xf2502cd2, 0xf298dcf0, 0x84b467f0, 0x1b39c9ab)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct69]:
if property_count != 14:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLH?LHfLH?LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(134))
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 UnknownStruct69(
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_vertical_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc241c65a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_right_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_left_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_massive_height_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_large_height_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_small_height_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_extra_drop_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_platform_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x935dfcfa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf2502cd2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf298dcf0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x84b467f0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1b39c9ab(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]]] = {
0xb6174a4e: ('vertical_offset', _decode_vertical_offset),
0xc241c65a: ('unknown_0xc241c65a', _decode_unknown_0xc241c65a),
0xcff710d0: ('look_right_distance', _decode_look_right_distance),
0x37f04700: ('look_left_distance', _decode_look_left_distance),
0xc7d11b34: ('massive_height_distance', _decode_massive_height_distance),
0x4ab0df83: ('large_height_distance', _decode_large_height_distance),
0xe0f4c8a2: ('small_height_distance', _decode_small_height_distance),
0xe7879b05: ('extra_drop_distance', _decode_extra_drop_distance),
0x76df8563: ('max_platform_distance', _decode_max_platform_distance),
0x935dfcfa: ('unknown_0x935dfcfa', _decode_unknown_0x935dfcfa),
0xf2502cd2: ('unknown_0xf2502cd2', _decode_unknown_0xf2502cd2),
0xf298dcf0: ('unknown_0xf298dcf0', _decode_unknown_0xf298dcf0),
0x84b467f0: ('unknown_0x84b467f0', _decode_unknown_0x84b467f0),
0x1b39c9ab: ('unknown_0x1b39c9ab', _decode_unknown_0x1b39c9ab),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct69.py | 0.69368 | 0.306579 | UnknownStruct69.py | 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.UnknownStruct270 import UnknownStruct270
@dataclasses.dataclass()
class UnknownStruct271(BaseProperty):
unknown_struct270: UnknownStruct270 = dataclasses.field(default_factory=UnknownStruct270)
unknown: float = dataclasses.field(default=2.0)
collision_offset: float = dataclasses.field(default=0.25)
sink_speed: float = dataclasses.field(default=3.0)
rise_speed: float = dataclasses.field(default=3.0)
kill_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]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'q\x90f\xeb') # 0x719066eb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct270.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfb\xa6\xa1\xd6') # 0xfba6a1d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xb4\x82\x8a\x9f') # 0xb4828a9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_offset))
data.write(b'19\xc1e') # 0x3139c165
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.sink_speed))
data.write(b'l\xf7\xe7\x07') # 0x6cf7e707
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rise_speed))
data.write(b'\xf4\x1aW\xe6') # 0xf41a57e6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.kill_threshold))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct270=UnknownStruct270.from_json(data['unknown_struct270']),
unknown=data['unknown'],
collision_offset=data['collision_offset'],
sink_speed=data['sink_speed'],
rise_speed=data['rise_speed'],
kill_threshold=data['kill_threshold'],
)
def to_json(self) -> dict:
return {
'unknown_struct270': self.unknown_struct270.to_json(),
'unknown': self.unknown,
'collision_offset': self.collision_offset,
'sink_speed': self.sink_speed,
'rise_speed': self.rise_speed,
'kill_threshold': self.kill_threshold,
}
def _decode_unknown_struct270(data: typing.BinaryIO, property_size: int):
return UnknownStruct270.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sink_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rise_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_kill_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]]] = {
0x719066eb: ('unknown_struct270', _decode_unknown_struct270),
0xfba6a1d6: ('unknown', _decode_unknown),
0xb4828a9f: ('collision_offset', _decode_collision_offset),
0x3139c165: ('sink_speed', _decode_sink_speed),
0x6cf7e707: ('rise_speed', _decode_rise_speed),
0xf41a57e6: ('kill_threshold', _decode_kill_threshold),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct271.py | 0.647352 | 0.291724 | UnknownStruct271.py | 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 UnknownStruct163(BaseProperty):
initial_duration: float = dataclasses.field(default=0.25)
show_title_duration: float = dataclasses.field(default=0.25)
show_buttons_duration: float = dataclasses.field(default=0.25)
unknown: 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\x04') # 4 properties
data.write(b'\x08\xe6\xc4/') # 0x8e6c42f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_duration))
data.write(b'\xd8J\xc0\xf5') # 0xd84ac0f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.show_title_duration))
data.write(b'\x1c\\0;') # 0x1c5c303b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.show_buttons_duration))
data.write(b'\xf0\xc5\x1c\x84') # 0xf0c51c84
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
initial_duration=data['initial_duration'],
show_title_duration=data['show_title_duration'],
show_buttons_duration=data['show_buttons_duration'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'initial_duration': self.initial_duration,
'show_title_duration': self.show_title_duration,
'show_buttons_duration': self.show_buttons_duration,
'unknown': self.unknown,
}
_FAST_FORMAT = None
_FAST_IDS = (0x8e6c42f, 0xd84ac0f5, 0x1c5c303b, 0xf0c51c84)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct163]:
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 UnknownStruct163(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_initial_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_show_title_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_show_buttons_duration(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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8e6c42f: ('initial_duration', _decode_initial_duration),
0xd84ac0f5: ('show_title_duration', _decode_show_title_duration),
0x1c5c303b: ('show_buttons_duration', _decode_show_buttons_duration),
0xf0c51c84: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct163.py | 0.657098 | 0.337054 | UnknownStruct163.py | 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 GuiWidgetProperties(BaseProperty):
gui_label: str = dataclasses.field(default='')
controller_number: int = dataclasses.field(default=1)
is_locked: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'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'\xdb\x7fJ\xa2') # 0xdb7f4aa2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.controller_number))
data.write(b'\xde\xe70\xf5') # 0xdee730f5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_locked))
@classmethod
def from_json(cls, data: dict):
return cls(
gui_label=data['gui_label'],
controller_number=data['controller_number'],
is_locked=data['is_locked'],
)
def to_json(self) -> dict:
return {
'gui_label': self.gui_label,
'controller_number': self.controller_number,
'is_locked': self.is_locked,
}
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_controller_number(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_locked(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]]] = {
0x73939407: ('gui_label', _decode_gui_label),
0xdb7f4aa2: ('controller_number', _decode_controller_number),
0xdee730f5: ('is_locked', _decode_is_locked),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/GuiWidgetProperties.py | 0.591369 | 0.30151 | GuiWidgetProperties.py | 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.Vector import Vector
@dataclasses.dataclass()
class LightParameters(BaseProperty):
ambient_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
world_lighting_options: enums.WorldLightingOptions = dataclasses.field(default=enums.WorldLightingOptions.NormalWorldLighting)
unknown_0x3dc5f0c6: bool = dataclasses.field(default=True)
light_recalculation: int = dataclasses.field(default=1)
lighting_position_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0xa71810e9: bool = dataclasses.field(default=True)
unknown_0x287de7be: bool = dataclasses.field(default=False)
unknown_0xc1b12bb4: bool = dataclasses.field(default=False)
ignore_ambient_lighting: bool = dataclasses.field(default=False)
unknown_0xb772d4c1: bool = dataclasses.field(default=True)
num_dynamic_lights: int = dataclasses.field(default=4)
num_area_lights: int = dataclasses.field(default=4)
unknown_0x9fdf211a: float = dataclasses.field(default=0.0)
use_light_set: 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]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'\xa3>[\x0e') # 0xa33e5b0e
data.write(b'\x00\x10') # size
self.ambient_color.to_stream(data)
data.write(b'k^u\t') # 0x6b5e7509
data.write(b'\x00\x04') # size
self.world_lighting_options.to_stream(data)
data.write(b'=\xc5\xf0\xc6') # 0x3dc5f0c6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3dc5f0c6))
data.write(b'b\x8ej\xc3') # 0x628e6ac3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.light_recalculation))
data.write(b'\xd1\x9d\xe7u') # 0xd19de775
data.write(b'\x00\x0c') # size
self.lighting_position_offset.to_stream(data)
data.write(b'\xa7\x18\x10\xe9') # 0xa71810e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa71810e9))
data.write(b'(}\xe7\xbe') # 0x287de7be
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x287de7be))
data.write(b'\xc1\xb1+\xb4') # 0xc1b12bb4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc1b12bb4))
data.write(b'a\xa9@\xd6') # 0x61a940d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_ambient_lighting))
data.write(b'\xb7r\xd4\xc1') # 0xb772d4c1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb772d4c1))
data.write(b'\xca\xc1\xe7x') # 0xcac1e778
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_dynamic_lights))
data.write(b'g\xf4\xd3\xde') # 0x67f4d3de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_area_lights))
data.write(b'\x9f\xdf!\x1a') # 0x9fdf211a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9fdf211a))
data.write(b'\x1fq_\xd3') # 0x1f715fd3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.use_light_set))
@classmethod
def from_json(cls, data: dict):
return cls(
ambient_color=Color.from_json(data['ambient_color']),
world_lighting_options=enums.WorldLightingOptions.from_json(data['world_lighting_options']),
unknown_0x3dc5f0c6=data['unknown_0x3dc5f0c6'],
light_recalculation=data['light_recalculation'],
lighting_position_offset=Vector.from_json(data['lighting_position_offset']),
unknown_0xa71810e9=data['unknown_0xa71810e9'],
unknown_0x287de7be=data['unknown_0x287de7be'],
unknown_0xc1b12bb4=data['unknown_0xc1b12bb4'],
ignore_ambient_lighting=data['ignore_ambient_lighting'],
unknown_0xb772d4c1=data['unknown_0xb772d4c1'],
num_dynamic_lights=data['num_dynamic_lights'],
num_area_lights=data['num_area_lights'],
unknown_0x9fdf211a=data['unknown_0x9fdf211a'],
use_light_set=data['use_light_set'],
)
def to_json(self) -> dict:
return {
'ambient_color': self.ambient_color.to_json(),
'world_lighting_options': self.world_lighting_options.to_json(),
'unknown_0x3dc5f0c6': self.unknown_0x3dc5f0c6,
'light_recalculation': self.light_recalculation,
'lighting_position_offset': self.lighting_position_offset.to_json(),
'unknown_0xa71810e9': self.unknown_0xa71810e9,
'unknown_0x287de7be': self.unknown_0x287de7be,
'unknown_0xc1b12bb4': self.unknown_0xc1b12bb4,
'ignore_ambient_lighting': self.ignore_ambient_lighting,
'unknown_0xb772d4c1': self.unknown_0xb772d4c1,
'num_dynamic_lights': self.num_dynamic_lights,
'num_area_lights': self.num_area_lights,
'unknown_0x9fdf211a': self.unknown_0x9fdf211a,
'use_light_set': self.use_light_set,
}
def _decode_ambient_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_world_lighting_options(data: typing.BinaryIO, property_size: int):
return enums.WorldLightingOptions.from_stream(data)
def _decode_unknown_0x3dc5f0c6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_light_recalculation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_lighting_position_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0xa71810e9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x287de7be(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xc1b12bb4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_ambient_lighting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb772d4c1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_num_dynamic_lights(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_num_area_lights(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x9fdf211a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_light_set(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]]] = {
0xa33e5b0e: ('ambient_color', _decode_ambient_color),
0x6b5e7509: ('world_lighting_options', _decode_world_lighting_options),
0x3dc5f0c6: ('unknown_0x3dc5f0c6', _decode_unknown_0x3dc5f0c6),
0x628e6ac3: ('light_recalculation', _decode_light_recalculation),
0xd19de775: ('lighting_position_offset', _decode_lighting_position_offset),
0xa71810e9: ('unknown_0xa71810e9', _decode_unknown_0xa71810e9),
0x287de7be: ('unknown_0x287de7be', _decode_unknown_0x287de7be),
0xc1b12bb4: ('unknown_0xc1b12bb4', _decode_unknown_0xc1b12bb4),
0x61a940d6: ('ignore_ambient_lighting', _decode_ignore_ambient_lighting),
0xb772d4c1: ('unknown_0xb772d4c1', _decode_unknown_0xb772d4c1),
0xcac1e778: ('num_dynamic_lights', _decode_num_dynamic_lights),
0x67f4d3de: ('num_area_lights', _decode_num_area_lights),
0x9fdf211a: ('unknown_0x9fdf211a', _decode_unknown_0x9fdf211a),
0x1f715fd3: ('use_light_set', _decode_use_light_set),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/LightParameters.py | 0.628521 | 0.294373 | LightParameters.py | 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 UnknownStruct23(BaseProperty):
unknown_0xf228ec53: float = dataclasses.field(default=3.0)
unknown_0xd91227f1: float = dataclasses.field(default=7.0)
unknown_0xfc764233: float = dataclasses.field(default=0.5)
unknown_0xe29028fc: float = dataclasses.field(default=10.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xf2(\xecS') # 0xf228ec53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf228ec53))
data.write(b"\xd9\x12'\xf1") # 0xd91227f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd91227f1))
data.write(b'\xfcvB3') # 0xfc764233
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfc764233))
data.write(b'\xe2\x90(\xfc') # 0xe29028fc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe29028fc))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xf228ec53=data['unknown_0xf228ec53'],
unknown_0xd91227f1=data['unknown_0xd91227f1'],
unknown_0xfc764233=data['unknown_0xfc764233'],
unknown_0xe29028fc=data['unknown_0xe29028fc'],
)
def to_json(self) -> dict:
return {
'unknown_0xf228ec53': self.unknown_0xf228ec53,
'unknown_0xd91227f1': self.unknown_0xd91227f1,
'unknown_0xfc764233': self.unknown_0xfc764233,
'unknown_0xe29028fc': self.unknown_0xe29028fc,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf228ec53, 0xd91227f1, 0xfc764233, 0xe29028fc)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct23]:
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 UnknownStruct23(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_unknown_0xf228ec53(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd91227f1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfc764233(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe29028fc(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]]] = {
0xf228ec53: ('unknown_0xf228ec53', _decode_unknown_0xf228ec53),
0xd91227f1: ('unknown_0xd91227f1', _decode_unknown_0xd91227f1),
0xfc764233: ('unknown_0xfc764233', _decode_unknown_0xfc764233),
0xe29028fc: ('unknown_0xe29028fc', _decode_unknown_0xe29028fc),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct23.py | 0.591487 | 0.282708 | UnknownStruct23.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Color import Color
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class UnknownStruct147(BaseProperty):
hud_frame: AssetId = dataclasses.field(metadata={'asset_types': ['FRME']}, default=default_asset_id)
board_transition_time: float = dataclasses.field(default=0.25)
board_rotation: Spline = dataclasses.field(default_factory=Spline)
visible_time: float = dataclasses.field(default=1.0)
unknown_0x5aedf7c9: float = dataclasses.field(default=0.05000000074505806)
transition_out_time: float = dataclasses.field(default=0.5)
fade_alpha: float = dataclasses.field(default=0.30000001192092896)
banana_increment_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
banana_reset_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
increment_delay: float = dataclasses.field(default=0.0625)
strg_0x569bd8a7: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
strg_0x7affc159: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
unknown_0xf7d838f6: float = dataclasses.field(default=0.30000001192092896)
strg_0x09f666e5: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
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=1.0, g=1.0, b=1.0, a=0.0))
unknown_0xa5f210ba: bool = dataclasses.field(default=True)
unknown_0x4038140e: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x13') # 19 properties
data.write(b'\xf2)\x9e\xd6') # 0xf2299ed6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_frame))
data.write(b'\x17*\xdd\xb3') # 0x172addb3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.board_transition_time))
data.write(b'i\xdc\n\x16') # 0x69dc0a16
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.board_rotation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'W\x04\x89|') # 0x5704897c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_time))
data.write(b'Z\xed\xf7\xc9') # 0x5aedf7c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5aedf7c9))
data.write(b'^J\x10v') # 0x5e4a1076
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.transition_out_time))
data.write(b']\x84\xac\xe2') # 0x5d84ace2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_alpha))
data.write(b'[\x92\x8a]') # 0x5b928a5d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.banana_increment_sound))
data.write(b'\xd8@Y\x8d') # 0xd840598d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.banana_reset_sound))
data.write(b'\xee\xb3\x90i') # 0xeeb39069
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.increment_delay))
data.write(b'V\x9b\xd8\xa7') # 0x569bd8a7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x569bd8a7))
data.write(b'z\xff\xc1Y') # 0x7affc159
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x7affc159))
data.write(b'\xf7\xd88\xf6') # 0xf7d838f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf7d838f6))
data.write(b'\t\xf6f\xe5') # 0x9f666e5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg_0x09f666e5))
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'\xa5\xf2\x10\xba') # 0xa5f210ba
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa5f210ba))
data.write(b'@8\x14\x0e') # 0x4038140e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4038140e))
@classmethod
def from_json(cls, data: dict):
return cls(
hud_frame=data['hud_frame'],
board_transition_time=data['board_transition_time'],
board_rotation=Spline.from_json(data['board_rotation']),
visible_time=data['visible_time'],
unknown_0x5aedf7c9=data['unknown_0x5aedf7c9'],
transition_out_time=data['transition_out_time'],
fade_alpha=data['fade_alpha'],
banana_increment_sound=data['banana_increment_sound'],
banana_reset_sound=data['banana_reset_sound'],
increment_delay=data['increment_delay'],
strg_0x569bd8a7=data['strg_0x569bd8a7'],
strg_0x7affc159=data['strg_0x7affc159'],
unknown_0xf7d838f6=data['unknown_0xf7d838f6'],
strg_0x09f666e5=data['strg_0x09f666e5'],
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']),
unknown_0xa5f210ba=data['unknown_0xa5f210ba'],
unknown_0x4038140e=data['unknown_0x4038140e'],
)
def to_json(self) -> dict:
return {
'hud_frame': self.hud_frame,
'board_transition_time': self.board_transition_time,
'board_rotation': self.board_rotation.to_json(),
'visible_time': self.visible_time,
'unknown_0x5aedf7c9': self.unknown_0x5aedf7c9,
'transition_out_time': self.transition_out_time,
'fade_alpha': self.fade_alpha,
'banana_increment_sound': self.banana_increment_sound,
'banana_reset_sound': self.banana_reset_sound,
'increment_delay': self.increment_delay,
'strg_0x569bd8a7': self.strg_0x569bd8a7,
'strg_0x7affc159': self.strg_0x7affc159,
'unknown_0xf7d838f6': self.unknown_0xf7d838f6,
'strg_0x09f666e5': self.strg_0x09f666e5,
'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(),
'unknown_0xa5f210ba': self.unknown_0xa5f210ba,
'unknown_0x4038140e': self.unknown_0x4038140e,
}
def _decode_hud_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_board_transition_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_board_rotation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_visible_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5aedf7c9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_transition_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_banana_increment_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_banana_reset_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_increment_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_strg_0x569bd8a7(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strg_0x7affc159(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xf7d838f6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_strg_0x09f666e5(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
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_unknown_0xa5f210ba(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4038140e(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]]] = {
0xf2299ed6: ('hud_frame', _decode_hud_frame),
0x172addb3: ('board_transition_time', _decode_board_transition_time),
0x69dc0a16: ('board_rotation', _decode_board_rotation),
0x5704897c: ('visible_time', _decode_visible_time),
0x5aedf7c9: ('unknown_0x5aedf7c9', _decode_unknown_0x5aedf7c9),
0x5e4a1076: ('transition_out_time', _decode_transition_out_time),
0x5d84ace2: ('fade_alpha', _decode_fade_alpha),
0x5b928a5d: ('banana_increment_sound', _decode_banana_increment_sound),
0xd840598d: ('banana_reset_sound', _decode_banana_reset_sound),
0xeeb39069: ('increment_delay', _decode_increment_delay),
0x569bd8a7: ('strg_0x569bd8a7', _decode_strg_0x569bd8a7),
0x7affc159: ('strg_0x7affc159', _decode_strg_0x7affc159),
0xf7d838f6: ('unknown_0xf7d838f6', _decode_unknown_0xf7d838f6),
0x9f666e5: ('strg_0x09f666e5', _decode_strg_0x09f666e5),
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),
0xa5f210ba: ('unknown_0xa5f210ba', _decode_unknown_0xa5f210ba),
0x4038140e: ('unknown_0x4038140e', _decode_unknown_0x4038140e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct147.py | 0.587115 | 0.18352 | UnknownStruct147.py | 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 AreaPathStructA(BaseProperty):
curvature: enums.Curvature = dataclasses.field(default=enums.Curvature.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'\xf4\xac|\xaa') # 0xf4ac7caa
data.write(b'\x00\x04') # size
self.curvature.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
curvature=enums.Curvature.from_json(data['curvature']),
)
def to_json(self) -> dict:
return {
'curvature': self.curvature.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0xf4ac7caa)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AreaPathStructA]:
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 AreaPathStructA(
enums.Curvature(dec[2]),
)
def _decode_curvature(data: typing.BinaryIO, property_size: int):
return enums.Curvature.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf4ac7caa: ('curvature', _decode_curvature),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/AreaPathStructA.py | 0.623492 | 0.295601 | AreaPathStructA.py | 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 VerticalFlightBehaviorData(BaseProperty):
apex_pause_time: float = dataclasses.field(default=0.0)
no_actor_collision: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'f\x0e\n0') # 0x660e0a30
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.apex_pause_time))
data.write(b';\xb9\x9cx') # 0x3bb99c78
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_actor_collision))
@classmethod
def from_json(cls, data: dict):
return cls(
apex_pause_time=data['apex_pause_time'],
no_actor_collision=data['no_actor_collision'],
)
def to_json(self) -> dict:
return {
'apex_pause_time': self.apex_pause_time,
'no_actor_collision': self.no_actor_collision,
}
_FAST_FORMAT = None
_FAST_IDS = (0x660e0a30, 0x3bb99c78)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VerticalFlightBehaviorData]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(17))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return VerticalFlightBehaviorData(
dec[2],
dec[5],
)
def _decode_apex_pause_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_no_actor_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x660e0a30: ('apex_pause_time', _decode_apex_pause_time),
0x3bb99c78: ('no_actor_collision', _decode_no_actor_collision),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/VerticalFlightBehaviorData.py | 0.643217 | 0.33008 | VerticalFlightBehaviorData.py | 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 UnknownStruct93(BaseProperty):
auto_loop_effect: bool = dataclasses.field(default=False)
auto_start_effect: bool = dataclasses.field(default=False)
effect_weight: Spline = dataclasses.field(default_factory=Spline)
screen_warp_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_0xb883ac66: float = dataclasses.field(default=0.0)
offset_v: float = dataclasses.field(default=0.0)
unknown_0xa02bb525: float = dataclasses.field(default=0.0)
unknown_0x26bfc78b: float = dataclasses.field(default=0.0)
unknown_0x83f8f585: float = dataclasses.field(default=30.0)
scale_factor: 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]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**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'\xc8\xfcI\xd0') # 0xc8fc49d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_loop_effect))
data.write(b'eG\x0f[') # 0x65470f5b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start_effect))
data.write(b'`W\x93\x8a') # 0x6057938a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.effect_weight.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'^\x96\x98\x9a') # 0x5e96989a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.screen_warp_texture))
data.write(b'\xb8\x83\xacf') # 0xb883ac66
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb883ac66))
data.write(b'>\x17\xde\xc8') # 0x3e17dec8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.offset_v))
data.write(b'\xa0+\xb5%') # 0xa02bb525
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa02bb525))
data.write(b'&\xbf\xc7\x8b') # 0x26bfc78b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x26bfc78b))
data.write(b'\x83\xf8\xf5\x85') # 0x83f8f585
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x83f8f585))
data.write(b'\xb2\x80}m') # 0xb2807d6d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.scale_factor))
@classmethod
def from_json(cls, data: dict):
return cls(
auto_loop_effect=data['auto_loop_effect'],
auto_start_effect=data['auto_start_effect'],
effect_weight=Spline.from_json(data['effect_weight']),
screen_warp_texture=data['screen_warp_texture'],
unknown_0xb883ac66=data['unknown_0xb883ac66'],
offset_v=data['offset_v'],
unknown_0xa02bb525=data['unknown_0xa02bb525'],
unknown_0x26bfc78b=data['unknown_0x26bfc78b'],
unknown_0x83f8f585=data['unknown_0x83f8f585'],
scale_factor=data['scale_factor'],
)
def to_json(self) -> dict:
return {
'auto_loop_effect': self.auto_loop_effect,
'auto_start_effect': self.auto_start_effect,
'effect_weight': self.effect_weight.to_json(),
'screen_warp_texture': self.screen_warp_texture,
'unknown_0xb883ac66': self.unknown_0xb883ac66,
'offset_v': self.offset_v,
'unknown_0xa02bb525': self.unknown_0xa02bb525,
'unknown_0x26bfc78b': self.unknown_0x26bfc78b,
'unknown_0x83f8f585': self.unknown_0x83f8f585,
'scale_factor': self.scale_factor,
}
def _decode_auto_loop_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_effect_weight(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_screen_warp_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xb883ac66(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_offset_v(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa02bb525(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x26bfc78b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x83f8f585(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scale_factor(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]]] = {
0xc8fc49d0: ('auto_loop_effect', _decode_auto_loop_effect),
0x65470f5b: ('auto_start_effect', _decode_auto_start_effect),
0x6057938a: ('effect_weight', _decode_effect_weight),
0x5e96989a: ('screen_warp_texture', _decode_screen_warp_texture),
0xb883ac66: ('unknown_0xb883ac66', _decode_unknown_0xb883ac66),
0x3e17dec8: ('offset_v', _decode_offset_v),
0xa02bb525: ('unknown_0xa02bb525', _decode_unknown_0xa02bb525),
0x26bfc78b: ('unknown_0x26bfc78b', _decode_unknown_0x26bfc78b),
0x83f8f585: ('unknown_0x83f8f585', _decode_unknown_0x83f8f585),
0xb2807d6d: ('scale_factor', _decode_scale_factor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct93.py | 0.630685 | 0.233073 | UnknownStruct93.py | 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 BopJumpData(BaseProperty):
height: float = dataclasses.field(default=1.0)
distance: float = dataclasses.field(default=0.5)
count: 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\x03') # 3 properties
data.write(b'\xc2\xbe\x03\r') # 0xc2be030d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.height))
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'2\x91\xb8\xa2') # 0x3291b8a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.count))
@classmethod
def from_json(cls, data: dict):
return cls(
height=data['height'],
distance=data['distance'],
count=data['count'],
)
def to_json(self) -> dict:
return {
'height': self.height,
'distance': self.distance,
'count': self.count,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc2be030d, 0xc3bf43be, 0x3291b8a2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[BopJumpData]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHl')
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 BopJumpData(
dec[2],
dec[5],
dec[8],
)
def _decode_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_count(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]]] = {
0xc2be030d: ('height', _decode_height),
0xc3bf43be: ('distance', _decode_distance),
0x3291b8a2: ('count', _decode_count),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/BopJumpData.py | 0.654564 | 0.340444 | BopJumpData.py | 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 UnknownStruct170(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
title_strings: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
instruction_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
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)
strg: 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\n') # 10 properties
data.write(b'0[22') # 0x305b3232
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17\xc8G\xc0') # 0x17c847c0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.title_strings))
data.write(b'7\xfd\x19\x13') # 0x37fd1913
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction))
data.write(b'\xa1O4\xca') # 0xa14f34ca
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.instruction_core))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'=\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'\x9c$\xf6\xc5') # 0x9c24f6c5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.strg))
data.write(b'\xe1\x191\x9b') # 0xe119319b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.text_background))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
title_strings=data['title_strings'],
instruction=data['instruction'],
instruction_core=data['instruction_core'],
back=data['back'],
back_core=data['back_core'],
unknown_0x3dc0f2be=data['unknown_0x3dc0f2be'],
unknown_0x6fdabad6=data['unknown_0x6fdabad6'],
strg=data['strg'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'title_strings': self.title_strings,
'instruction': self.instruction,
'instruction_core': self.instruction_core,
'back': self.back,
'back_core': self.back_core,
'unknown_0x3dc0f2be': self.unknown_0x3dc0f2be,
'unknown_0x6fdabad6': self.unknown_0x6fdabad6,
'strg': self.strg,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_title_strings(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_instruction_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_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_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_strg(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_text_background(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x305b3232: ('unknown_struct29', _decode_unknown_struct29),
0x17c847c0: ('title_strings', _decode_title_strings),
0x37fd1913: ('instruction', _decode_instruction),
0xa14f34ca: ('instruction_core', _decode_instruction_core),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x3dc0f2be: ('unknown_0x3dc0f2be', _decode_unknown_0x3dc0f2be),
0x6fdabad6: ('unknown_0x6fdabad6', _decode_unknown_0x6fdabad6),
0x9c24f6c5: ('strg', _decode_strg),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct170.py | 0.593727 | 0.192729 | UnknownStruct170.py | 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.LocomotionContextEnum import LocomotionContextEnum
from retro_data_structures.properties.dkc_returns.archetypes.WanderRandomTurnData import WanderRandomTurnData
@dataclasses.dataclass()
class WanderBehaviorData(BaseProperty):
move_toward_nearest_player_on_init: bool = dataclasses.field(default=False)
seek_player: bool = dataclasses.field(default=False)
use_seek_activation_range: bool = dataclasses.field(default=False)
seek_activation_range_squared: float = dataclasses.field(default=0.0)
maintain_distance: bool = dataclasses.field(default=False)
desired_distance: float = dataclasses.field(default=7.0)
min_time_between_direction_changes: float = dataclasses.field(default=1.0)
ignore_tar_inhibited_players: bool = dataclasses.field(default=False)
minimum_seek_direction_time: float = dataclasses.field(default=3.0)
use_seeking_tarred_player_locomotion_context: bool = dataclasses.field(default=False)
use_platform_edge_as_bounds: bool = dataclasses.field(default=False)
seeking_tarred_player_locomotion_context: LocomotionContextEnum = dataclasses.field(default_factory=LocomotionContextEnum)
enable_random_turn: bool = dataclasses.field(default=False)
random_turn: WanderRandomTurnData = dataclasses.field(default_factory=WanderRandomTurnData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'A\x83$Y') # 0x41832459
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.move_toward_nearest_player_on_init))
data.write(b'l\xea\x0e\xba') # 0x6cea0eba
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.seek_player))
data.write(b"\x14\xd0'\xb0") # 0x14d027b0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_seek_activation_range))
data.write(b'\x9b\x8b\xec\x06') # 0x9b8bec06
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.seek_activation_range_squared))
data.write(b'\x00\x9a\x130') # 0x9a1330
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.maintain_distance))
data.write(b'`\xbe5\xa1') # 0x60be35a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.desired_distance))
data.write(b'\x8f^wy') # 0x8f5e7779
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_time_between_direction_changes))
data.write(b'W\x18U\xa7') # 0x571855a7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_tar_inhibited_players))
data.write(b'\xe9\xe0\xbe\xb6') # 0xe9e0beb6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_seek_direction_time))
data.write(b'\x9a\xeb\x03\xd9') # 0x9aeb03d9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_seeking_tarred_player_locomotion_context))
data.write(b'\x9a\x12\x87\xd4') # 0x9a1287d4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_platform_edge_as_bounds))
data.write(b'\x12\x96\xe3\x16') # 0x1296e316
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seeking_tarred_player_locomotion_context.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\x8ce\x1f') # 0x938c651f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_random_turn))
data.write(b'f3\x87|') # 0x6633877c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.random_turn.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(
move_toward_nearest_player_on_init=data['move_toward_nearest_player_on_init'],
seek_player=data['seek_player'],
use_seek_activation_range=data['use_seek_activation_range'],
seek_activation_range_squared=data['seek_activation_range_squared'],
maintain_distance=data['maintain_distance'],
desired_distance=data['desired_distance'],
min_time_between_direction_changes=data['min_time_between_direction_changes'],
ignore_tar_inhibited_players=data['ignore_tar_inhibited_players'],
minimum_seek_direction_time=data['minimum_seek_direction_time'],
use_seeking_tarred_player_locomotion_context=data['use_seeking_tarred_player_locomotion_context'],
use_platform_edge_as_bounds=data['use_platform_edge_as_bounds'],
seeking_tarred_player_locomotion_context=LocomotionContextEnum.from_json(data['seeking_tarred_player_locomotion_context']),
enable_random_turn=data['enable_random_turn'],
random_turn=WanderRandomTurnData.from_json(data['random_turn']),
)
def to_json(self) -> dict:
return {
'move_toward_nearest_player_on_init': self.move_toward_nearest_player_on_init,
'seek_player': self.seek_player,
'use_seek_activation_range': self.use_seek_activation_range,
'seek_activation_range_squared': self.seek_activation_range_squared,
'maintain_distance': self.maintain_distance,
'desired_distance': self.desired_distance,
'min_time_between_direction_changes': self.min_time_between_direction_changes,
'ignore_tar_inhibited_players': self.ignore_tar_inhibited_players,
'minimum_seek_direction_time': self.minimum_seek_direction_time,
'use_seeking_tarred_player_locomotion_context': self.use_seeking_tarred_player_locomotion_context,
'use_platform_edge_as_bounds': self.use_platform_edge_as_bounds,
'seeking_tarred_player_locomotion_context': self.seeking_tarred_player_locomotion_context.to_json(),
'enable_random_turn': self.enable_random_turn,
'random_turn': self.random_turn.to_json(),
}
def _decode_move_toward_nearest_player_on_init(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_seek_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_seek_activation_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_seek_activation_range_squared(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maintain_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_desired_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_time_between_direction_changes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ignore_tar_inhibited_players(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_minimum_seek_direction_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_seeking_tarred_player_locomotion_context(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_platform_edge_as_bounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_seeking_tarred_player_locomotion_context(data: typing.BinaryIO, property_size: int):
return LocomotionContextEnum.from_stream(data, property_size)
def _decode_enable_random_turn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_random_turn(data: typing.BinaryIO, property_size: int):
return WanderRandomTurnData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x41832459: ('move_toward_nearest_player_on_init', _decode_move_toward_nearest_player_on_init),
0x6cea0eba: ('seek_player', _decode_seek_player),
0x14d027b0: ('use_seek_activation_range', _decode_use_seek_activation_range),
0x9b8bec06: ('seek_activation_range_squared', _decode_seek_activation_range_squared),
0x9a1330: ('maintain_distance', _decode_maintain_distance),
0x60be35a1: ('desired_distance', _decode_desired_distance),
0x8f5e7779: ('min_time_between_direction_changes', _decode_min_time_between_direction_changes),
0x571855a7: ('ignore_tar_inhibited_players', _decode_ignore_tar_inhibited_players),
0xe9e0beb6: ('minimum_seek_direction_time', _decode_minimum_seek_direction_time),
0x9aeb03d9: ('use_seeking_tarred_player_locomotion_context', _decode_use_seeking_tarred_player_locomotion_context),
0x9a1287d4: ('use_platform_edge_as_bounds', _decode_use_platform_edge_as_bounds),
0x1296e316: ('seeking_tarred_player_locomotion_context', _decode_seeking_tarred_player_locomotion_context),
0x938c651f: ('enable_random_turn', _decode_enable_random_turn),
0x6633877c: ('random_turn', _decode_random_turn),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/WanderBehaviorData.py | 0.636918 | 0.268318 | WanderBehaviorData.py | 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.VolcanoBossBodyPartStructC import VolcanoBossBodyPartStructC
@dataclasses.dataclass()
class UnknownStruct294(BaseProperty):
volcano_boss_body_part_struct_c_0x92807f97: VolcanoBossBodyPartStructC = dataclasses.field(default_factory=VolcanoBossBodyPartStructC)
volcano_boss_body_part_struct_c_0x7663abf3: VolcanoBossBodyPartStructC = dataclasses.field(default_factory=VolcanoBossBodyPartStructC)
volcano_boss_body_part_struct_c_0x8a4c3f96: VolcanoBossBodyPartStructC = dataclasses.field(default_factory=VolcanoBossBodyPartStructC)
volcano_boss_body_part_struct_c_0x70d8cac0: VolcanoBossBodyPartStructC = dataclasses.field(default_factory=VolcanoBossBodyPartStructC)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\x92\x80\x7f\x97') # 0x92807f97
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_c_0x92807f97.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'vc\xab\xf3') # 0x7663abf3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_c_0x7663abf3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8aL?\x96') # 0x8a4c3f96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_c_0x8a4c3f96.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'p\xd8\xca\xc0') # 0x70d8cac0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volcano_boss_body_part_struct_c_0x70d8cac0.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(
volcano_boss_body_part_struct_c_0x92807f97=VolcanoBossBodyPartStructC.from_json(data['volcano_boss_body_part_struct_c_0x92807f97']),
volcano_boss_body_part_struct_c_0x7663abf3=VolcanoBossBodyPartStructC.from_json(data['volcano_boss_body_part_struct_c_0x7663abf3']),
volcano_boss_body_part_struct_c_0x8a4c3f96=VolcanoBossBodyPartStructC.from_json(data['volcano_boss_body_part_struct_c_0x8a4c3f96']),
volcano_boss_body_part_struct_c_0x70d8cac0=VolcanoBossBodyPartStructC.from_json(data['volcano_boss_body_part_struct_c_0x70d8cac0']),
)
def to_json(self) -> dict:
return {
'volcano_boss_body_part_struct_c_0x92807f97': self.volcano_boss_body_part_struct_c_0x92807f97.to_json(),
'volcano_boss_body_part_struct_c_0x7663abf3': self.volcano_boss_body_part_struct_c_0x7663abf3.to_json(),
'volcano_boss_body_part_struct_c_0x8a4c3f96': self.volcano_boss_body_part_struct_c_0x8a4c3f96.to_json(),
'volcano_boss_body_part_struct_c_0x70d8cac0': self.volcano_boss_body_part_struct_c_0x70d8cac0.to_json(),
}
def _decode_volcano_boss_body_part_struct_c_0x92807f97(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructC.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_c_0x7663abf3(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructC.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_c_0x8a4c3f96(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructC.from_stream(data, property_size)
def _decode_volcano_boss_body_part_struct_c_0x70d8cac0(data: typing.BinaryIO, property_size: int):
return VolcanoBossBodyPartStructC.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x92807f97: ('volcano_boss_body_part_struct_c_0x92807f97', _decode_volcano_boss_body_part_struct_c_0x92807f97),
0x7663abf3: ('volcano_boss_body_part_struct_c_0x7663abf3', _decode_volcano_boss_body_part_struct_c_0x7663abf3),
0x8a4c3f96: ('volcano_boss_body_part_struct_c_0x8a4c3f96', _decode_volcano_boss_body_part_struct_c_0x8a4c3f96),
0x70d8cac0: ('volcano_boss_body_part_struct_c_0x70d8cac0', _decode_volcano_boss_body_part_struct_c_0x70d8cac0),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct294.py | 0.554229 | 0.282493 | UnknownStruct294.py | 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 DamagedBehaviorData(BaseProperty):
death_type: enums.DeathType = dataclasses.field(default=enums.DeathType.Unknown1)
flee_on_damaged: bool = dataclasses.field(default=False)
blink_when_damaged: bool = dataclasses.field(default=True)
flinch_from_ground_pound: bool = dataclasses.field(default=False)
allow_top_flinch: bool = dataclasses.field(default=False)
flinch_requires_perfect_match: bool = dataclasses.field(default=True)
stop_on_knockback: bool = dataclasses.field(default=False)
hurl_from_thrown_damage: 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\x08') # 8 properties
data.write(b'i\x9b\xfa\x8b') # 0x699bfa8b
data.write(b'\x00\x04') # size
self.death_type.to_stream(data)
data.write(b'\x97\xdet!') # 0x97de7421
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.flee_on_damaged))
data.write(b'U\xefZ\xb4') # 0x55ef5ab4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.blink_when_damaged))
data.write(b'y\xd2\x17\xbf') # 0x79d217bf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.flinch_from_ground_pound))
data.write(b'/_\xd5<') # 0x2f5fd53c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_top_flinch))
data.write(b'\xd6\xffg\xbf') # 0xd6ff67bf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.flinch_requires_perfect_match))
data.write(b'\xbe\xba\xf0\x85') # 0xbebaf085
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stop_on_knockback))
data.write(b'\x02*0`') # 0x22a3060
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hurl_from_thrown_damage))
@classmethod
def from_json(cls, data: dict):
return cls(
death_type=enums.DeathType.from_json(data['death_type']),
flee_on_damaged=data['flee_on_damaged'],
blink_when_damaged=data['blink_when_damaged'],
flinch_from_ground_pound=data['flinch_from_ground_pound'],
allow_top_flinch=data['allow_top_flinch'],
flinch_requires_perfect_match=data['flinch_requires_perfect_match'],
stop_on_knockback=data['stop_on_knockback'],
hurl_from_thrown_damage=data['hurl_from_thrown_damage'],
)
def to_json(self) -> dict:
return {
'death_type': self.death_type.to_json(),
'flee_on_damaged': self.flee_on_damaged,
'blink_when_damaged': self.blink_when_damaged,
'flinch_from_ground_pound': self.flinch_from_ground_pound,
'allow_top_flinch': self.allow_top_flinch,
'flinch_requires_perfect_match': self.flinch_requires_perfect_match,
'stop_on_knockback': self.stop_on_knockback,
'hurl_from_thrown_damage': self.hurl_from_thrown_damage,
}
_FAST_FORMAT = None
_FAST_IDS = (0x699bfa8b, 0x97de7421, 0x55ef5ab4, 0x79d217bf, 0x2f5fd53c, 0xd6ff67bf, 0xbebaf085, 0x22a3060)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DamagedBehaviorData]:
if property_count != 8:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(59))
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 DamagedBehaviorData(
enums.DeathType(dec[2]),
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
)
def _decode_death_type(data: typing.BinaryIO, property_size: int):
return enums.DeathType.from_stream(data)
def _decode_flee_on_damaged(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_blink_when_damaged(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flinch_from_ground_pound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_top_flinch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flinch_requires_perfect_match(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_stop_on_knockback(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hurl_from_thrown_damage(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]]] = {
0x699bfa8b: ('death_type', _decode_death_type),
0x97de7421: ('flee_on_damaged', _decode_flee_on_damaged),
0x55ef5ab4: ('blink_when_damaged', _decode_blink_when_damaged),
0x79d217bf: ('flinch_from_ground_pound', _decode_flinch_from_ground_pound),
0x2f5fd53c: ('allow_top_flinch', _decode_allow_top_flinch),
0xd6ff67bf: ('flinch_requires_perfect_match', _decode_flinch_requires_perfect_match),
0xbebaf085: ('stop_on_knockback', _decode_stop_on_knockback),
0x22a3060: ('hurl_from_thrown_damage', _decode_hurl_from_thrown_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DamagedBehaviorData.py | 0.613931 | 0.317876 | DamagedBehaviorData.py | 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 SplineType(BaseProperty):
type: 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'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
@classmethod
def from_json(cls, data: dict):
return cls(
type=data['type'],
)
def to_json(self) -> dict:
return {
'type': self.type,
}
_FAST_FORMAT = None
_FAST_IDS = (0xf53dcdd6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[SplineType]:
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 SplineType(
dec[2],
)
def _decode_type(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]]] = {
0xf53dcdd6: ('type', _decode_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/SplineType.py | 0.608827 | 0.305289 | SplineType.py | 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 UnknownStruct254(BaseProperty):
unknown_0xa35a8599: bool = dataclasses.field(default=False)
unknown_0xf8677de6: bool = dataclasses.field(default=False)
fully_pressed: float = dataclasses.field(default=1.0)
unknown_0x9fb991fe: float = dataclasses.field(default=0.5)
unknown_0xf12d036b: 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\x05') # 5 properties
data.write(b'\xa3Z\x85\x99') # 0xa35a8599
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa35a8599))
data.write(b'\xf8g}\xe6') # 0xf8677de6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf8677de6))
data.write(b'\xf6\xb9\xa61') # 0xf6b9a631
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fully_pressed))
data.write(b'\x9f\xb9\x91\xfe') # 0x9fb991fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9fb991fe))
data.write(b'\xf1-\x03k') # 0xf12d036b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf12d036b))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xa35a8599=data['unknown_0xa35a8599'],
unknown_0xf8677de6=data['unknown_0xf8677de6'],
fully_pressed=data['fully_pressed'],
unknown_0x9fb991fe=data['unknown_0x9fb991fe'],
unknown_0xf12d036b=data['unknown_0xf12d036b'],
)
def to_json(self) -> dict:
return {
'unknown_0xa35a8599': self.unknown_0xa35a8599,
'unknown_0xf8677de6': self.unknown_0xf8677de6,
'fully_pressed': self.fully_pressed,
'unknown_0x9fb991fe': self.unknown_0x9fb991fe,
'unknown_0xf12d036b': self.unknown_0xf12d036b,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa35a8599, 0xf8677de6, 0xf6b9a631, 0x9fb991fe, 0xf12d036b)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct254]:
if property_count != 5:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(44))
if (dec[0], dec[3], dec[6], dec[9], dec[12]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct254(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
)
def _decode_unknown_0xa35a8599(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf8677de6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fully_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9fb991fe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf12d036b(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]]] = {
0xa35a8599: ('unknown_0xa35a8599', _decode_unknown_0xa35a8599),
0xf8677de6: ('unknown_0xf8677de6', _decode_unknown_0xf8677de6),
0xf6b9a631: ('fully_pressed', _decode_fully_pressed),
0x9fb991fe: ('unknown_0x9fb991fe', _decode_unknown_0x9fb991fe),
0xf12d036b: ('unknown_0xf12d036b', _decode_unknown_0xf12d036b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct254.py | 0.593491 | 0.29111 | UnknownStruct254.py | 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.UnknownStruct251 import UnknownStruct251
@dataclasses.dataclass()
class UnknownStruct252(BaseProperty):
surface_height: float = dataclasses.field(default=0.0)
unknown: float = dataclasses.field(default=0.0)
unknown_struct251: UnknownStruct251 = dataclasses.field(default_factory=UnknownStruct251)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\n\x88j\xf5') # 0xa886af5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.surface_height))
data.write(b'\xe6\x1eDH') # 0xe61e4448
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xfeom\x0f') # 0xfe6f6d0f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct251.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(
surface_height=data['surface_height'],
unknown=data['unknown'],
unknown_struct251=UnknownStruct251.from_json(data['unknown_struct251']),
)
def to_json(self) -> dict:
return {
'surface_height': self.surface_height,
'unknown': self.unknown,
'unknown_struct251': self.unknown_struct251.to_json(),
}
def _decode_surface_height(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_struct251(data: typing.BinaryIO, property_size: int):
return UnknownStruct251.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa886af5: ('surface_height', _decode_surface_height),
0xe61e4448: ('unknown', _decode_unknown),
0xfe6f6d0f: ('unknown_struct251', _decode_unknown_struct251),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct252.py | 0.656438 | 0.291633 | UnknownStruct252.py | 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 UnknownStruct10(BaseProperty):
max_speed_x: float = dataclasses.field(default=10.0)
tracking_speed_x: float = dataclasses.field(default=6.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b' m\xea.') # 0x206dea2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_speed_x))
data.write(b'\xa5ti\xd3') # 0xa57469d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tracking_speed_x))
@classmethod
def from_json(cls, data: dict):
return cls(
max_speed_x=data['max_speed_x'],
tracking_speed_x=data['tracking_speed_x'],
)
def to_json(self) -> dict:
return {
'max_speed_x': self.max_speed_x,
'tracking_speed_x': self.tracking_speed_x,
}
_FAST_FORMAT = None
_FAST_IDS = (0x206dea2e, 0xa57469d3)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct10]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(20))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct10(
dec[2],
dec[5],
)
def _decode_max_speed_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tracking_speed_x(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]]] = {
0x206dea2e: ('max_speed_x', _decode_max_speed_x),
0xa57469d3: ('tracking_speed_x', _decode_tracking_speed_x),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct10.py | 0.68721 | 0.321114 | UnknownStruct10.py | 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 UnknownStruct251(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)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\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)
@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']),
)
def to_json(self) -> dict:
return {
'sound': self.sound,
'unknown': self.unknown.to_json(),
'pitch': self.pitch.to_json(),
'volume': self.volume.to_json(),
}
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)
_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),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct251.py | 0.658966 | 0.277934 | UnknownStruct251.py | 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.GenericCreatureStructC import GenericCreatureStructC
@dataclasses.dataclass()
class CollisionActorModifierData(BaseProperty):
number_of_collision_actor_sets: int = dataclasses.field(default=0)
actor_rule1: GenericCreatureStructC = dataclasses.field(default_factory=GenericCreatureStructC)
actor_rule2: GenericCreatureStructC = dataclasses.field(default_factory=GenericCreatureStructC)
actor_rule3: GenericCreatureStructC = dataclasses.field(default_factory=GenericCreatureStructC)
actor_rule4: GenericCreatureStructC = dataclasses.field(default_factory=GenericCreatureStructC)
actor_rule5: GenericCreatureStructC = dataclasses.field(default_factory=GenericCreatureStructC)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'iP\xb5\xda') # 0x6950b5da
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.number_of_collision_actor_sets))
data.write(b'\xd5Mo\xad') # 0xd54d6fad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_rule1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaeS\xedN') # 0xae53ed4e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_rule2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1\x89n\xd0') # 0x31896ed0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_rule3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Xn\xe8\x88') # 0x586ee888
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_rule4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7\xb4k\x16') # 0xc7b46b16
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_rule5.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_collision_actor_sets=data['number_of_collision_actor_sets'],
actor_rule1=GenericCreatureStructC.from_json(data['actor_rule1']),
actor_rule2=GenericCreatureStructC.from_json(data['actor_rule2']),
actor_rule3=GenericCreatureStructC.from_json(data['actor_rule3']),
actor_rule4=GenericCreatureStructC.from_json(data['actor_rule4']),
actor_rule5=GenericCreatureStructC.from_json(data['actor_rule5']),
)
def to_json(self) -> dict:
return {
'number_of_collision_actor_sets': self.number_of_collision_actor_sets,
'actor_rule1': self.actor_rule1.to_json(),
'actor_rule2': self.actor_rule2.to_json(),
'actor_rule3': self.actor_rule3.to_json(),
'actor_rule4': self.actor_rule4.to_json(),
'actor_rule5': self.actor_rule5.to_json(),
}
def _decode_number_of_collision_actor_sets(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_actor_rule1(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructC.from_stream(data, property_size)
def _decode_actor_rule2(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructC.from_stream(data, property_size)
def _decode_actor_rule3(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructC.from_stream(data, property_size)
def _decode_actor_rule4(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructC.from_stream(data, property_size)
def _decode_actor_rule5(data: typing.BinaryIO, property_size: int):
return GenericCreatureStructC.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6950b5da: ('number_of_collision_actor_sets', _decode_number_of_collision_actor_sets),
0xd54d6fad: ('actor_rule1', _decode_actor_rule1),
0xae53ed4e: ('actor_rule2', _decode_actor_rule2),
0x31896ed0: ('actor_rule3', _decode_actor_rule3),
0x586ee888: ('actor_rule4', _decode_actor_rule4),
0xc7b46b16: ('actor_rule5', _decode_actor_rule5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/CollisionActorModifierData.py | 0.59408 | 0.253653 | CollisionActorModifierData.py | 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 FollowPathControlBehaviorData(BaseProperty):
reverse_movement: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xff\xe2\x01\xa7') # 0xffe201a7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reverse_movement))
@classmethod
def from_json(cls, data: dict):
return cls(
reverse_movement=data['reverse_movement'],
)
def to_json(self) -> dict:
return {
'reverse_movement': self.reverse_movement,
}
_FAST_FORMAT = None
_FAST_IDS = (0xffe201a7)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FollowPathControlBehaviorData]:
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 FollowPathControlBehaviorData(
dec[2],
)
def _decode_reverse_movement(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xffe201a7: ('reverse_movement', _decode_reverse_movement),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/FollowPathControlBehaviorData.py | 0.615435 | 0.29682 | FollowPathControlBehaviorData.py | 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.RobotChickenStructA import RobotChickenStructA
@dataclasses.dataclass()
class UnknownStruct255(BaseProperty):
jump_count: int = dataclasses.field(default=1)
robot_chicken_struct_a_0x8792726d: RobotChickenStructA = dataclasses.field(default_factory=RobotChickenStructA)
robot_chicken_struct_a_0x229a1901: RobotChickenStructA = dataclasses.field(default_factory=RobotChickenStructA)
robot_chicken_struct_a_0x419dc025: RobotChickenStructA = dataclasses.field(default_factory=RobotChickenStructA)
robot_chicken_struct_a_0xb3fbc998: RobotChickenStructA = dataclasses.field(default_factory=RobotChickenStructA)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xad\xfdL\x91') # 0xadfd4c91
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.jump_count))
data.write(b'\x87\x92rm') # 0x8792726d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_a_0x8792726d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'"\x9a\x19\x01') # 0x229a1901
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_a_0x229a1901.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A\x9d\xc0%') # 0x419dc025
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_a_0x419dc025.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\xfb\xc9\x98') # 0xb3fbc998
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.robot_chicken_struct_a_0xb3fbc998.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(
jump_count=data['jump_count'],
robot_chicken_struct_a_0x8792726d=RobotChickenStructA.from_json(data['robot_chicken_struct_a_0x8792726d']),
robot_chicken_struct_a_0x229a1901=RobotChickenStructA.from_json(data['robot_chicken_struct_a_0x229a1901']),
robot_chicken_struct_a_0x419dc025=RobotChickenStructA.from_json(data['robot_chicken_struct_a_0x419dc025']),
robot_chicken_struct_a_0xb3fbc998=RobotChickenStructA.from_json(data['robot_chicken_struct_a_0xb3fbc998']),
)
def to_json(self) -> dict:
return {
'jump_count': self.jump_count,
'robot_chicken_struct_a_0x8792726d': self.robot_chicken_struct_a_0x8792726d.to_json(),
'robot_chicken_struct_a_0x229a1901': self.robot_chicken_struct_a_0x229a1901.to_json(),
'robot_chicken_struct_a_0x419dc025': self.robot_chicken_struct_a_0x419dc025.to_json(),
'robot_chicken_struct_a_0xb3fbc998': self.robot_chicken_struct_a_0xb3fbc998.to_json(),
}
def _decode_jump_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_robot_chicken_struct_a_0x8792726d(data: typing.BinaryIO, property_size: int):
return RobotChickenStructA.from_stream(data, property_size)
def _decode_robot_chicken_struct_a_0x229a1901(data: typing.BinaryIO, property_size: int):
return RobotChickenStructA.from_stream(data, property_size)
def _decode_robot_chicken_struct_a_0x419dc025(data: typing.BinaryIO, property_size: int):
return RobotChickenStructA.from_stream(data, property_size)
def _decode_robot_chicken_struct_a_0xb3fbc998(data: typing.BinaryIO, property_size: int):
return RobotChickenStructA.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xadfd4c91: ('jump_count', _decode_jump_count),
0x8792726d: ('robot_chicken_struct_a_0x8792726d', _decode_robot_chicken_struct_a_0x8792726d),
0x229a1901: ('robot_chicken_struct_a_0x229a1901', _decode_robot_chicken_struct_a_0x229a1901),
0x419dc025: ('robot_chicken_struct_a_0x419dc025', _decode_robot_chicken_struct_a_0x419dc025),
0xb3fbc998: ('robot_chicken_struct_a_0xb3fbc998', _decode_robot_chicken_struct_a_0xb3fbc998),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct255.py | 0.584745 | 0.344829 | UnknownStruct255.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct20(BaseProperty):
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))
font_outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
font_geometry_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
unknown_0x045c4906: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
unknown_0x9c403177: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
is_front_end: bool = dataclasses.field(default=False)
animation1: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
animation2: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x7024d89b: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x495c75db: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x19080ebd: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x2070a3fd: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\r') # 13 properties
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'\x84J\xb6\xb0') # 0x844ab6b0
data.write(b'\x00\x10') # size
self.font_outline_color.to_stream(data)
data.write(b'\xa6\xe3\x18z') # 0xa6e3187a
data.write(b'\x00\x10') # size
self.font_geometry_color.to_stream(data)
data.write(b'\x04\\I\x06') # 0x45c4906
data.write(b'\x00\x10') # size
self.unknown_0x045c4906.to_stream(data)
data.write(b'\x9c@1w') # 0x9c403177
data.write(b'\x00\x10') # size
self.unknown_0x9c403177.to_stream(data)
data.write(b'\x1fh\xf1\xb7') # 0x1f68f1b7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_front_end))
data.write(b')F>6') # 0x29463e36
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10>\x93v') # 0x103e9376
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'p$\xd8\x9b') # 0x7024d89b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7024d89b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'I\\u\xdb') # 0x495c75db
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x495c75db.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\x08\x0e\xbd') # 0x19080ebd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x19080ebd.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' p\xa3\xfd') # 0x2070a3fd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x2070a3fd.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(
gradient_start=Color.from_json(data['gradient_start']),
gradient_end=Color.from_json(data['gradient_end']),
font_outline_color=Color.from_json(data['font_outline_color']),
font_geometry_color=Color.from_json(data['font_geometry_color']),
unknown_0x045c4906=Color.from_json(data['unknown_0x045c4906']),
unknown_0x9c403177=Color.from_json(data['unknown_0x9c403177']),
is_front_end=data['is_front_end'],
animation1=AnimationParameters.from_json(data['animation1']),
animation2=AnimationParameters.from_json(data['animation2']),
unknown_0x7024d89b=AnimationParameters.from_json(data['unknown_0x7024d89b']),
unknown_0x495c75db=AnimationParameters.from_json(data['unknown_0x495c75db']),
unknown_0x19080ebd=AnimationParameters.from_json(data['unknown_0x19080ebd']),
unknown_0x2070a3fd=AnimationParameters.from_json(data['unknown_0x2070a3fd']),
)
def to_json(self) -> dict:
return {
'gradient_start': self.gradient_start.to_json(),
'gradient_end': self.gradient_end.to_json(),
'font_outline_color': self.font_outline_color.to_json(),
'font_geometry_color': self.font_geometry_color.to_json(),
'unknown_0x045c4906': self.unknown_0x045c4906.to_json(),
'unknown_0x9c403177': self.unknown_0x9c403177.to_json(),
'is_front_end': self.is_front_end,
'animation1': self.animation1.to_json(),
'animation2': self.animation2.to_json(),
'unknown_0x7024d89b': self.unknown_0x7024d89b.to_json(),
'unknown_0x495c75db': self.unknown_0x495c75db.to_json(),
'unknown_0x19080ebd': self.unknown_0x19080ebd.to_json(),
'unknown_0x2070a3fd': self.unknown_0x2070a3fd.to_json(),
}
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_font_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_font_geometry_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0x045c4906(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0x9c403177(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_is_front_end(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_animation1(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_animation2(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x7024d89b(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x495c75db(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x19080ebd(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x2070a3fd(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]]] = {
0xfbb7be45: ('gradient_start', _decode_gradient_start),
0xfbce3fb: ('gradient_end', _decode_gradient_end),
0x844ab6b0: ('font_outline_color', _decode_font_outline_color),
0xa6e3187a: ('font_geometry_color', _decode_font_geometry_color),
0x45c4906: ('unknown_0x045c4906', _decode_unknown_0x045c4906),
0x9c403177: ('unknown_0x9c403177', _decode_unknown_0x9c403177),
0x1f68f1b7: ('is_front_end', _decode_is_front_end),
0x29463e36: ('animation1', _decode_animation1),
0x103e9376: ('animation2', _decode_animation2),
0x7024d89b: ('unknown_0x7024d89b', _decode_unknown_0x7024d89b),
0x495c75db: ('unknown_0x495c75db', _decode_unknown_0x495c75db),
0x19080ebd: ('unknown_0x19080ebd', _decode_unknown_0x19080ebd),
0x2070a3fd: ('unknown_0x2070a3fd', _decode_unknown_0x2070a3fd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct20.py | 0.565659 | 0.262283 | UnknownStruct20.py | 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 UnknownStruct13(BaseProperty):
offset_method: enums.OffsetMethod = dataclasses.field(default=enums.OffsetMethod.Unknown1)
offset_spline: Spline = dataclasses.field(default_factory=Spline)
unknown: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\t&\x92\x9b') # 0x926929b
data.write(b'\x00\x04') # size
self.offset_method.to_stream(data)
data.write(b'\x19\x02\x8b\xd3') # 0x19028bd3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.offset_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\xfb\x16\xa2') # 0xf9fb16a2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
@classmethod
def from_json(cls, data: dict):
return cls(
offset_method=enums.OffsetMethod.from_json(data['offset_method']),
offset_spline=Spline.from_json(data['offset_spline']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'offset_method': self.offset_method.to_json(),
'offset_spline': self.offset_spline.to_json(),
'unknown': self.unknown,
}
def _decode_offset_method(data: typing.BinaryIO, property_size: int):
return enums.OffsetMethod.from_stream(data)
def _decode_offset_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x926929b: ('offset_method', _decode_offset_method),
0x19028bd3: ('offset_spline', _decode_offset_spline),
0xf9fb16a2: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct13.py | 0.678966 | 0.286556 | UnknownStruct13.py | 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.TouchAttackDirectionEnum import TouchAttackDirectionEnum
@dataclasses.dataclass()
class AdditiveTouchAttackBehaviorData(BaseProperty):
contact_top: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
contact_bottom: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
contact_front: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
contact_back: TouchAttackDirectionEnum = dataclasses.field(default_factory=TouchAttackDirectionEnum)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'\xff\n\x98\xa3') # 0xff0a98a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_top.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\nb\xc6P') # 0xa62c650
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_bottom.to_stream(data, default_override={'attack_direction': enums.AttackDirection.Unknown2})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95NP\xd4') # 0x954e50d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_front.to_stream(data, default_override={'attack_direction': enums.AttackDirection.Unknown5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'"\x9dy\xfe') # 0x229d79fe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_back.to_stream(data, default_override={'attack_direction': enums.AttackDirection.Unknown6})
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(
contact_top=TouchAttackDirectionEnum.from_json(data['contact_top']),
contact_bottom=TouchAttackDirectionEnum.from_json(data['contact_bottom']),
contact_front=TouchAttackDirectionEnum.from_json(data['contact_front']),
contact_back=TouchAttackDirectionEnum.from_json(data['contact_back']),
)
def to_json(self) -> dict:
return {
'contact_top': self.contact_top.to_json(),
'contact_bottom': self.contact_bottom.to_json(),
'contact_front': self.contact_front.to_json(),
'contact_back': self.contact_back.to_json(),
}
def _decode_contact_top(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size)
def _decode_contact_bottom(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size, default_override={'attack_direction': enums.AttackDirection.Unknown2})
def _decode_contact_front(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size, default_override={'attack_direction': enums.AttackDirection.Unknown5})
def _decode_contact_back(data: typing.BinaryIO, property_size: int):
return TouchAttackDirectionEnum.from_stream(data, property_size, default_override={'attack_direction': enums.AttackDirection.Unknown6})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xff0a98a3: ('contact_top', _decode_contact_top),
0xa62c650: ('contact_bottom', _decode_contact_bottom),
0x954e50d4: ('contact_front', _decode_contact_front),
0x229d79fe: ('contact_back', _decode_contact_back),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/AdditiveTouchAttackBehaviorData.py | 0.632843 | 0.251981 | AdditiveTouchAttackBehaviorData.py | 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 ConditionalTest(BaseProperty):
boolean: int = dataclasses.field(default=1) # Choice
use_connected_as_amount: bool = dataclasses.field(default=False)
player_item: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.Banana)
amount_or_capacity: int = dataclasses.field(default=0)
condition: int = dataclasses.field(default=0)
use_connected_as_value: bool = dataclasses.field(default=False)
value: 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\x07') # 7 properties
data.write(b'\xde>@\xa3') # 0xde3e40a3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.boolean))
data.write(b'yO\x9b\xeb') # 0x794f9beb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_connected_as_amount))
data.write(b'\xd3\xaf\x8dr') # 0xd3af8d72
data.write(b'\x00\x04') # size
self.player_item.to_stream(data)
data.write(b'\x03\xbd\xea\x98') # 0x3bdea98
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.amount_or_capacity))
data.write(b'pr\x93d') # 0x70729364
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.condition))
data.write(b'\xae\xb6\x94\xb4') # 0xaeb694b4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_connected_as_value))
data.write(b'\x8d\xb99\x8a') # 0x8db9398a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.value))
@classmethod
def from_json(cls, data: dict):
return cls(
boolean=data['boolean'],
use_connected_as_amount=data['use_connected_as_amount'],
player_item=enums.PlayerItem.from_json(data['player_item']),
amount_or_capacity=data['amount_or_capacity'],
condition=data['condition'],
use_connected_as_value=data['use_connected_as_value'],
value=data['value'],
)
def to_json(self) -> dict:
return {
'boolean': self.boolean,
'use_connected_as_amount': self.use_connected_as_amount,
'player_item': self.player_item.to_json(),
'amount_or_capacity': self.amount_or_capacity,
'condition': self.condition,
'use_connected_as_value': self.use_connected_as_value,
'value': self.value,
}
_FAST_FORMAT = None
_FAST_IDS = (0xde3e40a3, 0x794f9beb, 0xd3af8d72, 0x3bdea98, 0x70729364, 0xaeb694b4, 0x8db9398a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ConditionalTest]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLH?LHLLHlLHlLH?LHl')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(64))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return ConditionalTest(
dec[2],
dec[5],
enums.PlayerItem(dec[8]),
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_boolean(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_use_connected_as_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_player_item(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_amount_or_capacity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_condition(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_use_connected_as_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_value(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]]] = {
0xde3e40a3: ('boolean', _decode_boolean),
0x794f9beb: ('use_connected_as_amount', _decode_use_connected_as_amount),
0xd3af8d72: ('player_item', _decode_player_item),
0x3bdea98: ('amount_or_capacity', _decode_amount_or_capacity),
0x70729364: ('condition', _decode_condition),
0xaeb694b4: ('use_connected_as_value', _decode_use_connected_as_value),
0x8db9398a: ('value', _decode_value),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/ConditionalTest.py | 0.623492 | 0.279128 | ConditionalTest.py | 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 UnknownStruct172(BaseProperty):
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
image_names: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
back_core: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_arrow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
right_arrow: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_arrow_pressed: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
right_arrow_pressed: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
left_image_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
right_image_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, 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'\x11\x9eu\xac') # 0x119e75ac
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.image_names))
data.write(b'\xe93dU') # 0xe9336455
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back))
data.write(b'w\x0b\xcd;') # 0x770bcd3b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.back_core))
data.write(b'1L\xdc$') # 0x314cdc24
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_arrow))
data.write(b'\xd1\x91\x83G') # 0xd1918347
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_arrow))
data.write(b'\xb4Q\x0e\xfe') # 0xb4510efe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_arrow_pressed))
data.write(b'T\xcd\x18t') # 0x54cd1874
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_arrow_pressed))
data.write(b'\xc4+h\xc9') # 0xc42b68c9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_image_sound))
data.write(b'R\xf8//') # 0x52f82f2f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_image_sound))
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']),
image_names=data['image_names'],
back=data['back'],
back_core=data['back_core'],
left_arrow=data['left_arrow'],
right_arrow=data['right_arrow'],
left_arrow_pressed=data['left_arrow_pressed'],
right_arrow_pressed=data['right_arrow_pressed'],
left_image_sound=data['left_image_sound'],
right_image_sound=data['right_image_sound'],
text_background=data['text_background'],
)
def to_json(self) -> dict:
return {
'unknown_struct29': self.unknown_struct29.to_json(),
'image_names': self.image_names,
'back': self.back,
'back_core': self.back_core,
'left_arrow': self.left_arrow,
'right_arrow': self.right_arrow,
'left_arrow_pressed': self.left_arrow_pressed,
'right_arrow_pressed': self.right_arrow_pressed,
'left_image_sound': self.left_image_sound,
'right_image_sound': self.right_image_sound,
'text_background': self.text_background,
}
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.from_stream(data, property_size)
def _decode_image_names(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_back_core(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_arrow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_arrow(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_arrow_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_arrow_pressed(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_image_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_image_sound(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),
0x119e75ac: ('image_names', _decode_image_names),
0xe9336455: ('back', _decode_back),
0x770bcd3b: ('back_core', _decode_back_core),
0x314cdc24: ('left_arrow', _decode_left_arrow),
0xd1918347: ('right_arrow', _decode_right_arrow),
0xb4510efe: ('left_arrow_pressed', _decode_left_arrow_pressed),
0x54cd1874: ('right_arrow_pressed', _decode_right_arrow_pressed),
0xc42b68c9: ('left_image_sound', _decode_left_image_sound),
0x52f82f2f: ('right_image_sound', _decode_right_image_sound),
0xe119319b: ('text_background', _decode_text_background),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/UnknownStruct172.py | 0.605799 | 0.20001 | UnknownStruct172.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.dkc_returns.archetypes.LightParameters import LightParameters
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 DamageEffectData(BaseProperty):
bounds: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
apply_damage_to_any_vulnerable_actor: bool = dataclasses.field(default=False)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
duration: float = dataclasses.field(default=5.0)
turn_damage_off_delay_after_emitter_shut_down: float = dataclasses.field(default=0.0)
draw_debug_box_multiplier: float = dataclasses.field(default=2.0)
force_delete_multiplier: float = dataclasses.field(default=4.0)
speed: float = dataclasses.field(default=0.0)
use_terrain_alignment: bool = dataclasses.field(default=False)
terrain_search_up_distance: float = dataclasses.field(default=0.5)
override_terrain_search_radius: bool = dataclasses.field(default=False)
terrain_search_radius: float = dataclasses.field(default=0.5)
terrain_alignment_rotation_speed: float = dataclasses.field(default=360.0)
terrain_alignment_speed_k: float = dataclasses.field(default=0.10000000149011612)
use_terrain_neighbor_influences: bool = dataclasses.field(default=True)
align_velocity_with_surface: bool = dataclasses.field(default=False)
align_effect: bool = dataclasses.field(default=False)
can_be_blown_out: bool = dataclasses.field(default=False)
particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
time_scale: float = dataclasses.field(default=1.0)
model_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
kill_sound_when_effect_ends: bool = dataclasses.field(default=False)
use_alternate_damage_effect: bool = dataclasses.field(default=False)
use_lighting: bool = dataclasses.field(default=False)
lighting: LightParameters = dataclasses.field(default_factory=LightParameters)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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\x1a') # 26 properties
data.write(b';\xbe\xee\xd2') # 0x3bbeeed2
data.write(b'\x00\x0c') # size
self.bounds.to_stream(data)
data.write(b'A\x8dR\xd4') # 0x418d52d4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.apply_damage_to_any_vulnerable_actor))
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'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\xf3\x11*\xd9') # 0xf3112ad9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_damage_off_delay_after_emitter_shut_down))
data.write(b'\xd1\xefrH') # 0xd1ef7248
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.draw_debug_box_multiplier))
data.write(b'\xa9=\xe02') # 0xa93de032
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.force_delete_multiplier))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'a\x17\xe7\x8f') # 0x6117e78f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_terrain_alignment))
data.write(b'\xdb\x1cq\xc2') # 0xdb1c71c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.terrain_search_up_distance))
data.write(b'#\xeel\x1d') # 0x23ee6c1d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.override_terrain_search_radius))
data.write(b'#1\xd4\x18') # 0x2331d418
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.terrain_search_radius))
data.write(b'\xa8\x84\xe6?') # 0xa884e63f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.terrain_alignment_rotation_speed))
data.write(b'\xe4\x07n\x11') # 0xe4076e11
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.terrain_alignment_speed_k))
data.write(b'\xa8c\xba\xe2') # 0xa863bae2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_terrain_neighbor_influences))
data.write(b'\xd1\xe5\xb0B') # 0xd1e5b042
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.align_velocity_with_surface))
data.write(b'D\x1d\x86G') # 0x441d8647
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.align_effect))
data.write(b'\xd5As8') # 0xd5417338
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_blown_out))
data.write(b'm\x1c\xe5%') # 0x6d1ce525
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle))
data.write(b'>\xdftk') # 0x3edf746b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_scale))
data.write(b'\xeameH') # 0xea6d6548
data.write(b'\x00\x0c') # size
self.model_scale.to_stream(data)
data.write(b'\xa5]\xac\xf6') # 0xa55dacf6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound))
data.write(b'x\xa6a\xef') # 0x78a661ef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.kill_sound_when_effect_ends))
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'\x81\x8d\x8d\xae') # 0x818d8dae
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_lighting))
data.write(b'\xb0(\xdb\x0e') # 0xb028db0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.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(
bounds=Vector.from_json(data['bounds']),
apply_damage_to_any_vulnerable_actor=data['apply_damage_to_any_vulnerable_actor'],
damage=DamageInfo.from_json(data['damage']),
duration=data['duration'],
turn_damage_off_delay_after_emitter_shut_down=data['turn_damage_off_delay_after_emitter_shut_down'],
draw_debug_box_multiplier=data['draw_debug_box_multiplier'],
force_delete_multiplier=data['force_delete_multiplier'],
speed=data['speed'],
use_terrain_alignment=data['use_terrain_alignment'],
terrain_search_up_distance=data['terrain_search_up_distance'],
override_terrain_search_radius=data['override_terrain_search_radius'],
terrain_search_radius=data['terrain_search_radius'],
terrain_alignment_rotation_speed=data['terrain_alignment_rotation_speed'],
terrain_alignment_speed_k=data['terrain_alignment_speed_k'],
use_terrain_neighbor_influences=data['use_terrain_neighbor_influences'],
align_velocity_with_surface=data['align_velocity_with_surface'],
align_effect=data['align_effect'],
can_be_blown_out=data['can_be_blown_out'],
particle=data['particle'],
time_scale=data['time_scale'],
model_scale=Vector.from_json(data['model_scale']),
sound=data['sound'],
kill_sound_when_effect_ends=data['kill_sound_when_effect_ends'],
use_alternate_damage_effect=data['use_alternate_damage_effect'],
use_lighting=data['use_lighting'],
lighting=LightParameters.from_json(data['lighting']),
)
def to_json(self) -> dict:
return {
'bounds': self.bounds.to_json(),
'apply_damage_to_any_vulnerable_actor': self.apply_damage_to_any_vulnerable_actor,
'damage': self.damage.to_json(),
'duration': self.duration,
'turn_damage_off_delay_after_emitter_shut_down': self.turn_damage_off_delay_after_emitter_shut_down,
'draw_debug_box_multiplier': self.draw_debug_box_multiplier,
'force_delete_multiplier': self.force_delete_multiplier,
'speed': self.speed,
'use_terrain_alignment': self.use_terrain_alignment,
'terrain_search_up_distance': self.terrain_search_up_distance,
'override_terrain_search_radius': self.override_terrain_search_radius,
'terrain_search_radius': self.terrain_search_radius,
'terrain_alignment_rotation_speed': self.terrain_alignment_rotation_speed,
'terrain_alignment_speed_k': self.terrain_alignment_speed_k,
'use_terrain_neighbor_influences': self.use_terrain_neighbor_influences,
'align_velocity_with_surface': self.align_velocity_with_surface,
'align_effect': self.align_effect,
'can_be_blown_out': self.can_be_blown_out,
'particle': self.particle,
'time_scale': self.time_scale,
'model_scale': self.model_scale.to_json(),
'sound': self.sound,
'kill_sound_when_effect_ends': self.kill_sound_when_effect_ends,
'use_alternate_damage_effect': self.use_alternate_damage_effect,
'use_lighting': self.use_lighting,
'lighting': self.lighting.to_json(),
}
def _decode_bounds(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_apply_damage_to_any_vulnerable_actor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_damage_off_delay_after_emitter_shut_down(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_draw_debug_box_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_force_delete_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_terrain_alignment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_terrain_search_up_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_override_terrain_search_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_terrain_search_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_terrain_alignment_rotation_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_terrain_alignment_speed_k(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_use_terrain_neighbor_influences(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_align_velocity_with_surface(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_align_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_be_blown_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_time_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_kill_sound_when_effect_ends(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_use_lighting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x3bbeeed2: ('bounds', _decode_bounds),
0x418d52d4: ('apply_damage_to_any_vulnerable_actor', _decode_apply_damage_to_any_vulnerable_actor),
0x337f9524: ('damage', _decode_damage),
0x8b51e23f: ('duration', _decode_duration),
0xf3112ad9: ('turn_damage_off_delay_after_emitter_shut_down', _decode_turn_damage_off_delay_after_emitter_shut_down),
0xd1ef7248: ('draw_debug_box_multiplier', _decode_draw_debug_box_multiplier),
0xa93de032: ('force_delete_multiplier', _decode_force_delete_multiplier),
0x6392404e: ('speed', _decode_speed),
0x6117e78f: ('use_terrain_alignment', _decode_use_terrain_alignment),
0xdb1c71c2: ('terrain_search_up_distance', _decode_terrain_search_up_distance),
0x23ee6c1d: ('override_terrain_search_radius', _decode_override_terrain_search_radius),
0x2331d418: ('terrain_search_radius', _decode_terrain_search_radius),
0xa884e63f: ('terrain_alignment_rotation_speed', _decode_terrain_alignment_rotation_speed),
0xe4076e11: ('terrain_alignment_speed_k', _decode_terrain_alignment_speed_k),
0xa863bae2: ('use_terrain_neighbor_influences', _decode_use_terrain_neighbor_influences),
0xd1e5b042: ('align_velocity_with_surface', _decode_align_velocity_with_surface),
0x441d8647: ('align_effect', _decode_align_effect),
0xd5417338: ('can_be_blown_out', _decode_can_be_blown_out),
0x6d1ce525: ('particle', _decode_particle),
0x3edf746b: ('time_scale', _decode_time_scale),
0xea6d6548: ('model_scale', _decode_model_scale),
0xa55dacf6: ('sound', _decode_sound),
0x78a661ef: ('kill_sound_when_effect_ends', _decode_kill_sound_when_effect_ends),
0xf0993bfe: ('use_alternate_damage_effect', _decode_use_alternate_damage_effect),
0x818d8dae: ('use_lighting', _decode_use_lighting),
0xb028db0e: ('lighting', _decode_lighting),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/DamageEffectData.py | 0.613815 | 0.262254 | DamageEffectData.py | 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 PlayerAttackBounceData(BaseProperty):
minimum_attack_bounce_height: float = dataclasses.field(default=3.25)
maximum_attack_bounce_height: float = dataclasses.field(default=5.25)
low_shielded_attack_bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
high_shielded_attack_bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
low_damage_attack_bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
high_damage_attack_bounce_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
controller_attack_bounce_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\x07') # 7 properties
data.write(b'0\xf6\xa3k') # 0x30f6a36b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_attack_bounce_height))
data.write(b'\x80\xc9\xb9W') # 0x80c9b957
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_attack_bounce_height))
data.write(b']\x84\x9e\xf9') # 0x5d849ef9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.low_shielded_attack_bounce_sound))
data.write(b'\xd8\x0f\x96\xc2') # 0xd80f96c2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.high_shielded_attack_bounce_sound))
data.write(b'\x95@\x82F') # 0x95408246
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.low_damage_attack_bounce_sound))
data.write(b'\xa3\xc2\xfcD') # 0xa3c2fc44
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.high_damage_attack_bounce_sound))
data.write(b'\xb9\xa2\xaf}') # 0xb9a2af7d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.controller_attack_bounce_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
minimum_attack_bounce_height=data['minimum_attack_bounce_height'],
maximum_attack_bounce_height=data['maximum_attack_bounce_height'],
low_shielded_attack_bounce_sound=data['low_shielded_attack_bounce_sound'],
high_shielded_attack_bounce_sound=data['high_shielded_attack_bounce_sound'],
low_damage_attack_bounce_sound=data['low_damage_attack_bounce_sound'],
high_damage_attack_bounce_sound=data['high_damage_attack_bounce_sound'],
controller_attack_bounce_sound=data['controller_attack_bounce_sound'],
)
def to_json(self) -> dict:
return {
'minimum_attack_bounce_height': self.minimum_attack_bounce_height,
'maximum_attack_bounce_height': self.maximum_attack_bounce_height,
'low_shielded_attack_bounce_sound': self.low_shielded_attack_bounce_sound,
'high_shielded_attack_bounce_sound': self.high_shielded_attack_bounce_sound,
'low_damage_attack_bounce_sound': self.low_damage_attack_bounce_sound,
'high_damage_attack_bounce_sound': self.high_damage_attack_bounce_sound,
'controller_attack_bounce_sound': self.controller_attack_bounce_sound,
}
_FAST_FORMAT = None
_FAST_IDS = (0x30f6a36b, 0x80c9b957, 0x5d849ef9, 0xd80f96c2, 0x95408246, 0xa3c2fc44, 0xb9a2af7d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerAttackBounceData]:
if property_count != 7:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHQLHQLHQLHQLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(90))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18]) != _FAST_IDS:
data.seek(before)
return None
return PlayerAttackBounceData(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
)
def _decode_minimum_attack_bounce_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_attack_bounce_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_low_shielded_attack_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_high_shielded_attack_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_low_damage_attack_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_high_damage_attack_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_controller_attack_bounce_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]]] = {
0x30f6a36b: ('minimum_attack_bounce_height', _decode_minimum_attack_bounce_height),
0x80c9b957: ('maximum_attack_bounce_height', _decode_maximum_attack_bounce_height),
0x5d849ef9: ('low_shielded_attack_bounce_sound', _decode_low_shielded_attack_bounce_sound),
0xd80f96c2: ('high_shielded_attack_bounce_sound', _decode_high_shielded_attack_bounce_sound),
0x95408246: ('low_damage_attack_bounce_sound', _decode_low_damage_attack_bounce_sound),
0xa3c2fc44: ('high_damage_attack_bounce_sound', _decode_high_damage_attack_bounce_sound),
0xb9a2af7d: ('controller_attack_bounce_sound', _decode_controller_attack_bounce_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerAttackBounceData.py | 0.643553 | 0.252712 | PlayerAttackBounceData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.dkc_returns.archetypes.PlayerAttackBounceData import PlayerAttackBounceData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerBarrelCannonData(BaseProperty):
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
barrel_cannon_effect_locator: str = dataclasses.field(default='')
wall_bounce_constant: float = dataclasses.field(default=0.5)
max_land_carry_over_speed: float = dataclasses.field(default=4.5)
attack_damage_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
attack_bounce_data: PlayerAttackBounceData = dataclasses.field(default_factory=PlayerAttackBounceData)
unknown_0xe06d7b15: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x4364525d: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x2abd7e71: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'8\x18\x82\xd7') # 0x381882d7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.part))
data.write(b'\xbd\x8e\x1d9') # 0xbd8e1d39
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.barrel_cannon_effect_locator.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'H\xb5\xde\xf1') # 0x48b5def1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_bounce_constant))
data.write(b'L\x97\xben') # 0x4c97be6e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_land_carry_over_speed))
data.write(b'kN\xd7\x18') # 0x6b4ed718
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.attack_damage_sound))
data.write(b'\x95\x83\xee\x9a') # 0x9583ee9a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_bounce_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0m{\x15') # 0xe06d7b15
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0xe06d7b15))
data.write(b'CdR]') # 0x4364525d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x4364525d))
data.write(b'*\xbd~q') # 0x2abd7e71
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x2abd7e71))
@classmethod
def from_json(cls, data: dict):
return cls(
part=data['part'],
barrel_cannon_effect_locator=data['barrel_cannon_effect_locator'],
wall_bounce_constant=data['wall_bounce_constant'],
max_land_carry_over_speed=data['max_land_carry_over_speed'],
attack_damage_sound=data['attack_damage_sound'],
attack_bounce_data=PlayerAttackBounceData.from_json(data['attack_bounce_data']),
unknown_0xe06d7b15=data['unknown_0xe06d7b15'],
unknown_0x4364525d=data['unknown_0x4364525d'],
unknown_0x2abd7e71=data['unknown_0x2abd7e71'],
)
def to_json(self) -> dict:
return {
'part': self.part,
'barrel_cannon_effect_locator': self.barrel_cannon_effect_locator,
'wall_bounce_constant': self.wall_bounce_constant,
'max_land_carry_over_speed': self.max_land_carry_over_speed,
'attack_damage_sound': self.attack_damage_sound,
'attack_bounce_data': self.attack_bounce_data.to_json(),
'unknown_0xe06d7b15': self.unknown_0xe06d7b15,
'unknown_0x4364525d': self.unknown_0x4364525d,
'unknown_0x2abd7e71': self.unknown_0x2abd7e71,
}
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_barrel_cannon_effect_locator(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_wall_bounce_constant(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_land_carry_over_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_damage_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_attack_bounce_data(data: typing.BinaryIO, property_size: int):
return PlayerAttackBounceData.from_stream(data, property_size)
def _decode_unknown_0xe06d7b15(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x4364525d(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x2abd7e71(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]]] = {
0x381882d7: ('part', _decode_part),
0xbd8e1d39: ('barrel_cannon_effect_locator', _decode_barrel_cannon_effect_locator),
0x48b5def1: ('wall_bounce_constant', _decode_wall_bounce_constant),
0x4c97be6e: ('max_land_carry_over_speed', _decode_max_land_carry_over_speed),
0x6b4ed718: ('attack_damage_sound', _decode_attack_damage_sound),
0x9583ee9a: ('attack_bounce_data', _decode_attack_bounce_data),
0xe06d7b15: ('unknown_0xe06d7b15', _decode_unknown_0xe06d7b15),
0x4364525d: ('unknown_0x4364525d', _decode_unknown_0x4364525d),
0x2abd7e71: ('unknown_0x2abd7e71', _decode_unknown_0x2abd7e71),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerBarrelCannonData.py | 0.612657 | 0.250752 | PlayerBarrelCannonData.py | 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 RobotChickenFlyerStructA(BaseProperty):
gravity: float = dataclasses.field(default=55.0)
acceleration: float = dataclasses.field(default=20.0)
deceleration: float = dataclasses.field(default=12.0)
maximum_speed: float = dataclasses.field(default=12.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(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'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
data.write(b'\x9e\xc4\xfc\x10') # 0x9ec4fc10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.deceleration))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
@classmethod
def from_json(cls, data: dict):
return cls(
gravity=data['gravity'],
acceleration=data['acceleration'],
deceleration=data['deceleration'],
maximum_speed=data['maximum_speed'],
)
def to_json(self) -> dict:
return {
'gravity': self.gravity,
'acceleration': self.acceleration,
'deceleration': self.deceleration,
'maximum_speed': self.maximum_speed,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2f2ae3e5, 0x39fb7978, 0x9ec4fc10, 0x140ef2cc)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RobotChickenFlyerStructA]:
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 RobotChickenFlyerStructA(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_deceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2f2ae3e5: ('gravity', _decode_gravity),
0x39fb7978: ('acceleration', _decode_acceleration),
0x9ec4fc10: ('deceleration', _decode_deceleration),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/RobotChickenFlyerStructA.py | 0.768168 | 0.32752 | RobotChickenFlyerStructA.py | 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.BeatUpHandlerStruct import BeatUpHandlerStruct
from retro_data_structures.properties.dkc_returns.archetypes.ControlCommands import ControlCommands
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Data(BaseProperty):
left_command: ControlCommands = dataclasses.field(default_factory=ControlCommands)
control_command: ControlCommands = dataclasses.field(default_factory=ControlCommands)
swing_delay_same: float = dataclasses.field(default=1.0)
swing_delay_different: float = dataclasses.field(default=0.10000000149011612)
swing_delay_any: float = dataclasses.field(default=0.10000000149011612)
randomize_hits: bool = dataclasses.field(default=False)
skip_initial_hit: bool = dataclasses.field(default=False)
allow_both_players_to_hit: bool = dataclasses.field(default=False)
max_beat_up_time: float = dataclasses.field(default=0.0)
max_multiplier: int = dataclasses.field(default=100)
prize1: BeatUpHandlerStruct = dataclasses.field(default_factory=BeatUpHandlerStruct)
prize2: BeatUpHandlerStruct = dataclasses.field(default_factory=BeatUpHandlerStruct)
prize3: BeatUpHandlerStruct = dataclasses.field(default_factory=BeatUpHandlerStruct)
hit_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0e') # 14 properties
data.write(b'\xf6\xae]|') # 0xf6ae5d7c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.left_command.to_stream(data, default_override={'command': enums.Command.Unknown8})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd2\xfdOt') # 0xd2fd4f74
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.control_command.to_stream(data, default_override={'command': enums.Command.Unknown9})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'5\xd4\x0bg') # 0x35d40b67
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_delay_same))
data.write(b'\x82\x94\x13\x81') # 0x82941381
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_delay_different))
data.write(b'\xe87v\xe6') # 0xe83776e6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swing_delay_any))
data.write(b'\xf8\x04\xd4\x1c') # 0xf804d41c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.randomize_hits))
data.write(b'\xe3\x99\xb7Z') # 0xe399b75a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.skip_initial_hit))
data.write(b'\xdd1\xe5Z') # 0xdd31e55a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_both_players_to_hit))
data.write(b'\xb5\xbb\xe8\x8a') # 0xb5bbe88a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_beat_up_time))
data.write(b'\xb1.X\xb8') # 0xb12e58b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_multiplier))
data.write(b'B\x89\xb1[') # 0x4289b15b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prize1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'5\x17c\xab') # 0x351763ab
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prize2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xae\xb2/\xc4') # 0xaeb22fc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prize3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'U-\xb7,') # 0x552db72c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hit_sound))
@classmethod
def from_json(cls, data: dict):
return cls(
left_command=ControlCommands.from_json(data['left_command']),
control_command=ControlCommands.from_json(data['control_command']),
swing_delay_same=data['swing_delay_same'],
swing_delay_different=data['swing_delay_different'],
swing_delay_any=data['swing_delay_any'],
randomize_hits=data['randomize_hits'],
skip_initial_hit=data['skip_initial_hit'],
allow_both_players_to_hit=data['allow_both_players_to_hit'],
max_beat_up_time=data['max_beat_up_time'],
max_multiplier=data['max_multiplier'],
prize1=BeatUpHandlerStruct.from_json(data['prize1']),
prize2=BeatUpHandlerStruct.from_json(data['prize2']),
prize3=BeatUpHandlerStruct.from_json(data['prize3']),
hit_sound=data['hit_sound'],
)
def to_json(self) -> dict:
return {
'left_command': self.left_command.to_json(),
'control_command': self.control_command.to_json(),
'swing_delay_same': self.swing_delay_same,
'swing_delay_different': self.swing_delay_different,
'swing_delay_any': self.swing_delay_any,
'randomize_hits': self.randomize_hits,
'skip_initial_hit': self.skip_initial_hit,
'allow_both_players_to_hit': self.allow_both_players_to_hit,
'max_beat_up_time': self.max_beat_up_time,
'max_multiplier': self.max_multiplier,
'prize1': self.prize1.to_json(),
'prize2': self.prize2.to_json(),
'prize3': self.prize3.to_json(),
'hit_sound': self.hit_sound,
}
def _decode_left_command(data: typing.BinaryIO, property_size: int):
return ControlCommands.from_stream(data, property_size, default_override={'command': enums.Command.Unknown8})
def _decode_control_command(data: typing.BinaryIO, property_size: int):
return ControlCommands.from_stream(data, property_size, default_override={'command': enums.Command.Unknown9})
def _decode_swing_delay_same(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_delay_different(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swing_delay_any(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_randomize_hits(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_skip_initial_hit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_both_players_to_hit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_beat_up_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_prize1(data: typing.BinaryIO, property_size: int):
return BeatUpHandlerStruct.from_stream(data, property_size)
def _decode_prize2(data: typing.BinaryIO, property_size: int):
return BeatUpHandlerStruct.from_stream(data, property_size)
def _decode_prize3(data: typing.BinaryIO, property_size: int):
return BeatUpHandlerStruct.from_stream(data, property_size)
def _decode_hit_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]]] = {
0xf6ae5d7c: ('left_command', _decode_left_command),
0xd2fd4f74: ('control_command', _decode_control_command),
0x35d40b67: ('swing_delay_same', _decode_swing_delay_same),
0x82941381: ('swing_delay_different', _decode_swing_delay_different),
0xe83776e6: ('swing_delay_any', _decode_swing_delay_any),
0xf804d41c: ('randomize_hits', _decode_randomize_hits),
0xe399b75a: ('skip_initial_hit', _decode_skip_initial_hit),
0xdd31e55a: ('allow_both_players_to_hit', _decode_allow_both_players_to_hit),
0xb5bbe88a: ('max_beat_up_time', _decode_max_beat_up_time),
0xb12e58b8: ('max_multiplier', _decode_max_multiplier),
0x4289b15b: ('prize1', _decode_prize1),
0x351763ab: ('prize2', _decode_prize2),
0xaeb22fc4: ('prize3', _decode_prize3),
0x552db72c: ('hit_sound', _decode_hit_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/Data.py | 0.642657 | 0.222975 | Data.py | 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 PlayerMovementParameters(BaseProperty):
minimum_walk_speed: float = dataclasses.field(default=1.0)
maximum_run_speed: float = dataclasses.field(default=9.0)
acceleration: 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\x03') # 3 properties
data.write(b'\x1f\xf7\x90`') # 0x1ff79060
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_walk_speed))
data.write(b'\x95\n{\x96') # 0x950a7b96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_run_speed))
data.write(b'9\xfbyx') # 0x39fb7978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration))
@classmethod
def from_json(cls, data: dict):
return cls(
minimum_walk_speed=data['minimum_walk_speed'],
maximum_run_speed=data['maximum_run_speed'],
acceleration=data['acceleration'],
)
def to_json(self) -> dict:
return {
'minimum_walk_speed': self.minimum_walk_speed,
'maximum_run_speed': self.maximum_run_speed,
'acceleration': self.acceleration,
}
_FAST_FORMAT = None
_FAST_IDS = (0x1ff79060, 0x950a7b96, 0x39fb7978)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerMovementParameters]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return PlayerMovementParameters(
dec[2],
dec[5],
dec[8],
)
def _decode_minimum_walk_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_run_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1ff79060: ('minimum_walk_speed', _decode_minimum_walk_speed),
0x950a7b96: ('maximum_run_speed', _decode_maximum_run_speed),
0x39fb7978: ('acceleration', _decode_acceleration),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/archetypes/PlayerMovementParameters.py | 0.809502 | 0.32611 | PlayerMovementParameters.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.