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 BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class MusicModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fade_up_time: float = dataclasses.field(default=0.25)
fade_down_time: float = dataclasses.field(default=0.25)
fade_volume_multiplier: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SAMD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\r!\xd3H') # 0xd21d348
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_up_time))
data.write(b'\xf9w\xcb5') # 0xf977cb35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_down_time))
data.write(b'\xdc\t\x1b\xd4') # 0xdc091bd4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_volume_multiplier))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
fade_up_time=data['fade_up_time'],
fade_down_time=data['fade_down_time'],
fade_volume_multiplier=data['fade_volume_multiplier'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'fade_up_time': self.fade_up_time,
'fade_down_time': self.fade_down_time,
'fade_volume_multiplier': self.fade_volume_multiplier,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_fade_up_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_down_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_volume_multiplier(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd21d348: ('fade_up_time', _decode_fade_up_time),
0xf977cb35: ('fade_down_time', _decode_fade_down_time),
0xdc091bd4: ('fade_volume_multiplier', _decode_fade_volume_multiplier),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MusicModifier.py | 0.657978 | 0.320888 | MusicModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
hint_type: int = dataclasses.field(default=0)
radius: float = dataclasses.field(default=0.0)
value_parm: float = dataclasses.field(default=0.0)
value_parm2: float = dataclasses.field(default=0.0)
value_parm3: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIHT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\x12{q') # 0xb3127b71
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.hint_type))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\x19\x02\x80\x99') # 0x19028099
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm))
data.write(b',\x93\xaa\xf5') # 0x2c93aaf5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm2))
data.write(b'\xe7\xcfyP') # 0xe7cf7950
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm3))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
hint_type=data['hint_type'],
radius=data['radius'],
value_parm=data['value_parm'],
value_parm2=data['value_parm2'],
value_parm3=data['value_parm3'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'hint_type': self.hint_type,
'radius': self.radius,
'value_parm': self.value_parm,
'value_parm2': self.value_parm2,
'value_parm3': self.value_parm3,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_hint_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm3(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3127b71: ('hint_type', _decode_hint_type),
0x78c507eb: ('radius', _decode_radius),
0x19028099: ('value_parm', _decode_value_parm),
0x2c93aaf5: ('value_parm2', _decode_value_parm2),
0xe7cf7950: ('value_parm3', _decode_value_parm3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AIHint.py | 0.612657 | 0.345712 | AIHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct273 import UnknownStruct273
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct274 import UnknownStruct274
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct275 import UnknownStruct275
@dataclasses.dataclass()
class TrainTrackManager(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct273: UnknownStruct273 = dataclasses.field(default_factory=UnknownStruct273)
unknown_struct274: UnknownStruct274 = dataclasses.field(default_factory=UnknownStruct274)
unknown_struct275: UnknownStruct275 = dataclasses.field(default_factory=UnknownStruct275)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TMGR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MoleTrain.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'>\xdfW\xb4') # 0x3edf57b4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct273.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01\x9c\x93\x92') # 0x19c9392
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct274.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18q\xba\x9b') # 0x1871ba9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct275.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct273=UnknownStruct273.from_json(data['unknown_struct273']),
unknown_struct274=UnknownStruct274.from_json(data['unknown_struct274']),
unknown_struct275=UnknownStruct275.from_json(data['unknown_struct275']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct273': self.unknown_struct273.to_json(),
'unknown_struct274': self.unknown_struct274.to_json(),
'unknown_struct275': self.unknown_struct275.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct273(data: typing.BinaryIO, property_size: int):
return UnknownStruct273.from_stream(data, property_size)
def _decode_unknown_struct274(data: typing.BinaryIO, property_size: int):
return UnknownStruct274.from_stream(data, property_size)
def _decode_unknown_struct275(data: typing.BinaryIO, property_size: int):
return UnknownStruct275.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3edf57b4: ('unknown_struct273', _decode_unknown_struct273),
0x19c9392: ('unknown_struct274', _decode_unknown_struct274),
0x1871ba9b: ('unknown_struct275', _decode_unknown_struct275),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TrainTrackManager.py | 0.597138 | 0.333056 | TrainTrackManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct83 import UnknownStruct83
@dataclasses.dataclass()
class PirateCrabManager(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct83: UnknownStruct83 = dataclasses.field(default_factory=UnknownStruct83)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CMGR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PirateCrab.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'^\xcb\x9ak') # 0x5ecb9a6b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct83.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct83=UnknownStruct83.from_json(data['unknown_struct83']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct83': self.unknown_struct83.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct83(data: typing.BinaryIO, property_size: int):
return UnknownStruct83.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x5ecb9a6b: ('unknown_struct83', _decode_unknown_struct83),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PirateCrabManager.py | 0.620737 | 0.344885 | PirateCrabManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.Convergence import Convergence
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PlatformMotionProperties import PlatformMotionProperties
@dataclasses.dataclass()
class MotionPlatform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
motion_properties: PlatformMotionProperties = dataclasses.field(default_factory=PlatformMotionProperties)
max_velocity: float = dataclasses.field(default=1.0)
elevation_velocity: float = dataclasses.field(default=1.0)
radius: float = dataclasses.field(default=10.0)
elevation: float = dataclasses.field(default=0.0)
max_elevation: float = dataclasses.field(default=1.0)
min_elevation: float = dataclasses.field(default=-1.0)
direction: enums.Direction = dataclasses.field(default=enums.Direction.Unknown1)
convergence: Convergence = dataclasses.field(default_factory=Convergence)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MNPL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\n\x9d\xbf\x91') # 0xa9dbf91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4\xf8\x9c\x8f') # 0xe4f89c8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_velocity))
data.write(b';;\x92\xa6') # 0x3b3b92a6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.elevation_velocity))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\xc58B\x00') # 0xc5384200
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.elevation))
data.write(b'\xcch\x06\xa1') # 0xcc6806a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_elevation))
data.write(b'\xd9\xe3\xd2S') # 0xd9e3d253
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_elevation))
data.write(b'\nD\x1e\x0c') # 0xa441e0c
data.write(b'\x00\x04') # size
self.direction.to_stream(data)
data.write(b'V\xf4\xbc\x93') # 0x56f4bc93
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
motion_properties=PlatformMotionProperties.from_json(data['motion_properties']),
max_velocity=data['max_velocity'],
elevation_velocity=data['elevation_velocity'],
radius=data['radius'],
elevation=data['elevation'],
max_elevation=data['max_elevation'],
min_elevation=data['min_elevation'],
direction=enums.Direction.from_json(data['direction']),
convergence=Convergence.from_json(data['convergence']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'motion_properties': self.motion_properties.to_json(),
'max_velocity': self.max_velocity,
'elevation_velocity': self.elevation_velocity,
'radius': self.radius,
'elevation': self.elevation,
'max_elevation': self.max_elevation,
'min_elevation': self.min_elevation,
'direction': self.direction.to_json(),
'convergence': self.convergence.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_motion_properties(data: typing.BinaryIO, property_size: int):
return PlatformMotionProperties.from_stream(data, property_size)
def _decode_max_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_elevation_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_elevation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_elevation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_elevation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_direction(data: typing.BinaryIO, property_size: int):
return enums.Direction.from_stream(data)
def _decode_convergence(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa9dbf91: ('motion_properties', _decode_motion_properties),
0xe4f89c8f: ('max_velocity', _decode_max_velocity),
0x3b3b92a6: ('elevation_velocity', _decode_elevation_velocity),
0x78c507eb: ('radius', _decode_radius),
0xc5384200: ('elevation', _decode_elevation),
0xcc6806a1: ('max_elevation', _decode_max_elevation),
0xd9e3d253: ('min_elevation', _decode_min_elevation),
0xa441e0c: ('direction', _decode_direction),
0x56f4bc93: ('convergence', _decode_convergence),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MotionPlatform.py | 0.608827 | 0.391406 | MotionPlatform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct264 import UnknownStruct264
@dataclasses.dataclass()
class RelayRandom(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct264: UnknownStruct264 = dataclasses.field(default_factory=UnknownStruct264)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'86\xc4\x03') # 0x3836c403
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct264.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct264=UnknownStruct264.from_json(data['unknown_struct264']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct264': self.unknown_struct264.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct264(data: typing.BinaryIO, property_size: int):
return UnknownStruct264.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3836c403: ('unknown_struct264', _decode_unknown_struct264),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RelayRandom.py | 0.625209 | 0.351784 | RelayRandom.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.BalloonBarrelData import BalloonBarrelData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class BarrelBalloon(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
balloon_barrel_data: BalloonBarrelData = dataclasses.field(default_factory=BalloonBarrelData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BABL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94\xf9\xc4\x8d') # 0x94f9c48d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balloon_barrel_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
balloon_barrel_data=BalloonBarrelData.from_json(data['balloon_barrel_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'balloon_barrel_data': self.balloon_barrel_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_balloon_barrel_data(data: typing.BinaryIO, property_size: int):
return BalloonBarrelData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x94f9c48d: ('balloon_barrel_data', _decode_balloon_barrel_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BarrelBalloon.py | 0.691497 | 0.309232 | BarrelBalloon.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.Connection import Connection
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SequenceTimer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
sequence_connections: list[Connection] = dataclasses.field(default_factory=list)
start_time: float = dataclasses.field(default=0.0)
max_time: float = dataclasses.field(default=60.0)
loop_start_time: float = dataclasses.field(default=0.0)
is_autostart: bool = dataclasses.field(default=False)
is_loop: bool = dataclasses.field(default=False)
take_external_time: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SQTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xef\\\x94\xe9') # 0xef5c94e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
array = self.sequence_connections
data.write(struct.pack(">L", len(array)))
for item in array:
item.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8\xbd!u') # 0xb8bd2175
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_time))
data.write(b'\x03\xe7\xb2\xb4') # 0x3e7b2b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_time))
data.write(b'\xac\xf9\xca_') # 0xacf9ca5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.loop_start_time))
data.write(b'B\xc6\xe2\xb2') # 0x42c6e2b2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_autostart))
data.write(b'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b"'\xb3\xb0\x82") # 0x27b3b082
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.take_external_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
sequence_connections=[Connection.from_json(item) for item in data['sequence_connections']],
start_time=data['start_time'],
max_time=data['max_time'],
loop_start_time=data['loop_start_time'],
is_autostart=data['is_autostart'],
is_loop=data['is_loop'],
take_external_time=data['take_external_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'sequence_connections': [item.to_json() for item in self.sequence_connections],
'start_time': self.start_time,
'max_time': self.max_time,
'loop_start_time': self.loop_start_time,
'is_autostart': self.is_autostart,
'is_loop': self.is_loop,
'take_external_time': self.take_external_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_sequence_connections(data: typing.BinaryIO, property_size: int):
return [Connection.from_stream(data, property_size) for _ in range(struct.unpack(">L", data.read(4))[0])]
def _decode_start_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_loop_start_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_autostart(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_take_external_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xef5c94e9: ('sequence_connections', _decode_sequence_connections),
0xb8bd2175: ('start_time', _decode_start_time),
0x3e7b2b4: ('max_time', _decode_max_time),
0xacf9ca5f: ('loop_start_time', _decode_loop_start_time),
0x42c6e2b2: ('is_autostart', _decode_is_autostart),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x27b3b082: ('take_external_time', _decode_take_external_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SequenceTimer.py | 0.616243 | 0.356111 | SequenceTimer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PickupData import PickupData
from retro_data_structures.properties.dkc_returns.archetypes.SavedStateID import SavedStateID
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct244 import UnknownStruct244
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 Pickup(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
object_id: SavedStateID = dataclasses.field(default_factory=SavedStateID)
collision_size: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
ghost_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
ghost_character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
pickup_data: PickupData = dataclasses.field(default_factory=PickupData)
can_cause_damage: bool = dataclasses.field(default=False)
unknown_struct244: UnknownStruct244 = dataclasses.field(default_factory=UnknownStruct244)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PCKP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\xd9\xa7]') # 0x16d9a75d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.object_id.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b':>\x03\xba') # 0x3a3e03ba
data.write(b'\x00\x0c') # size
self.collision_size.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
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',\xf4\tx') # 0x2cf40978
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ghost_model))
data.write(b'1(\x97o') # 0x3128976f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ghost_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'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd5E\xf3k') # 0xd545f36b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pickup_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb07M4') # 0xb0374d34
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_cause_damage))
data.write(b'\x9d\xa7\xab\xfa') # 0x9da7abfa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct244.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
object_id=SavedStateID.from_json(data['object_id']),
collision_size=Vector.from_json(data['collision_size']),
collision_offset=Vector.from_json(data['collision_offset']),
model=data['model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
ghost_model=data['ghost_model'],
ghost_character_animation_information=AnimationParameters.from_json(data['ghost_character_animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
pickup_data=PickupData.from_json(data['pickup_data']),
can_cause_damage=data['can_cause_damage'],
unknown_struct244=UnknownStruct244.from_json(data['unknown_struct244']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'object_id': self.object_id.to_json(),
'collision_size': self.collision_size.to_json(),
'collision_offset': self.collision_offset.to_json(),
'model': self.model,
'character_animation_information': self.character_animation_information.to_json(),
'ghost_model': self.ghost_model,
'ghost_character_animation_information': self.ghost_character_animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'pickup_data': self.pickup_data.to_json(),
'can_cause_damage': self.can_cause_damage,
'unknown_struct244': self.unknown_struct244.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_object_id(data: typing.BinaryIO, property_size: int):
return SavedStateID.from_stream(data, property_size)
def _decode_collision_size(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_ghost_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ghost_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_pickup_data(data: typing.BinaryIO, property_size: int):
return PickupData.from_stream(data, property_size)
def _decode_can_cause_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct244(data: typing.BinaryIO, property_size: int):
return UnknownStruct244.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x16d9a75d: ('object_id', _decode_object_id),
0x3a3e03ba: ('collision_size', _decode_collision_size),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xc27ffa8f: ('model', _decode_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x2cf40978: ('ghost_model', _decode_ghost_model),
0x3128976f: ('ghost_character_animation_information', _decode_ghost_character_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xd545f36b: ('pickup_data', _decode_pickup_data),
0xb0374d34: ('can_cause_damage', _decode_can_cause_damage),
0x9da7abfa: ('unknown_struct244', _decode_unknown_struct244),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Pickup.py | 0.514644 | 0.255616 | Pickup.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.CameraManagerData import CameraManagerData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CameraManager(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
camera_manager_data: CameraManagerData = dataclasses.field(default_factory=CameraManagerData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CMAN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14nd\xde') # 0x146e64de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_manager_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
camera_manager_data=CameraManagerData.from_json(data['camera_manager_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'camera_manager_data': self.camera_manager_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_camera_manager_data(data: typing.BinaryIO, property_size: int):
return CameraManagerData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x146e64de: ('camera_manager_data', _decode_camera_manager_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CameraManager.py | 0.677047 | 0.371821 | CameraManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ActorKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0xc215a24f: int = dataclasses.field(default=0)
mirrored: bool = dataclasses.field(default=False)
force_secondary: bool = dataclasses.field(default=False)
loop: bool = dataclasses.field(default=False)
loop_duration: float = dataclasses.field(default=0.0)
unknown_0x6d62ef74: int = dataclasses.field(default=8)
playback_rate: float = dataclasses.field(default=1.0)
playback_blend_mode: enums.AnimEnum = dataclasses.field(default=enums.AnimEnum.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ACKF'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\t') # 9 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x15\xa2O') # 0xc215a24f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc215a24f))
data.write(b'\x1f\xe4L:') # 0x1fe44c3a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.mirrored))
data.write(b'\\\xce[\x97') # 0x5cce5b97
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_secondary))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\xce\xe6\x87#') # 0xcee68723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.loop_duration))
data.write(b'mb\xeft') # 0x6d62ef74
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6d62ef74))
data.write(b'o\x8d4\xca') # 0x6f8d34ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.playback_rate))
data.write(b'\xed\x1f\x8a\xab') # 0xed1f8aab
data.write(b'\x00\x04') # size
self.playback_blend_mode.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_0xc215a24f=data['unknown_0xc215a24f'],
mirrored=data['mirrored'],
force_secondary=data['force_secondary'],
loop=data['loop'],
loop_duration=data['loop_duration'],
unknown_0x6d62ef74=data['unknown_0x6d62ef74'],
playback_rate=data['playback_rate'],
playback_blend_mode=enums.AnimEnum.from_json(data['playback_blend_mode']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0xc215a24f': self.unknown_0xc215a24f,
'mirrored': self.mirrored,
'force_secondary': self.force_secondary,
'loop': self.loop,
'loop_duration': self.loop_duration,
'unknown_0x6d62ef74': self.unknown_0x6d62ef74,
'playback_rate': self.playback_rate,
'playback_blend_mode': self.playback_blend_mode.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0xc215a24f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mirrored(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_force_secondary(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6d62ef74(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_playback_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_playback_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.AnimEnum.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc215a24f: ('unknown_0xc215a24f', _decode_unknown_0xc215a24f),
0x1fe44c3a: ('mirrored', _decode_mirrored),
0x5cce5b97: ('force_secondary', _decode_force_secondary),
0xeda47ff6: ('loop', _decode_loop),
0xcee68723: ('loop_duration', _decode_loop_duration),
0x6d62ef74: ('unknown_0x6d62ef74', _decode_unknown_0x6d62ef74),
0x6f8d34ca: ('playback_rate', _decode_playback_rate),
0xed1f8aab: ('playback_blend_mode', _decode_playback_blend_mode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ActorKeyframe.py | 0.617513 | 0.300002 | ActorKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PickupRelayStruct import PickupRelayStruct
@dataclasses.dataclass()
class ProbabilityRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
prob1_p: PickupRelayStruct = dataclasses.field(default_factory=PickupRelayStruct)
prob2_p: PickupRelayStruct = dataclasses.field(default_factory=PickupRelayStruct)
prob_time_attack: PickupRelayStruct = dataclasses.field(default_factory=PickupRelayStruct)
prob_mirror_mode: PickupRelayStruct = dataclasses.field(default_factory=PickupRelayStruct)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PRLA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18\xe3\xb4\xe9') # 0x18e3b4e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prob1_p.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\x9b\x19\xa9') # 0x219b19a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prob2_p.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\x1c\xb4e') # 0x121cb465
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prob_time_attack.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xff\xb7\xa5\xbe') # 0xffb7a5be
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.prob_mirror_mode.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
prob1_p=PickupRelayStruct.from_json(data['prob1_p']),
prob2_p=PickupRelayStruct.from_json(data['prob2_p']),
prob_time_attack=PickupRelayStruct.from_json(data['prob_time_attack']),
prob_mirror_mode=PickupRelayStruct.from_json(data['prob_mirror_mode']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'prob1_p': self.prob1_p.to_json(),
'prob2_p': self.prob2_p.to_json(),
'prob_time_attack': self.prob_time_attack.to_json(),
'prob_mirror_mode': self.prob_mirror_mode.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_prob1_p(data: typing.BinaryIO, property_size: int):
return PickupRelayStruct.from_stream(data, property_size)
def _decode_prob2_p(data: typing.BinaryIO, property_size: int):
return PickupRelayStruct.from_stream(data, property_size)
def _decode_prob_time_attack(data: typing.BinaryIO, property_size: int):
return PickupRelayStruct.from_stream(data, property_size)
def _decode_prob_mirror_mode(data: typing.BinaryIO, property_size: int):
return PickupRelayStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x18e3b4e9: ('prob1_p', _decode_prob1_p),
0x219b19a9: ('prob2_p', _decode_prob2_p),
0x121cb465: ('prob_time_attack', _decode_prob_time_attack),
0xffb7a5be: ('prob_mirror_mode', _decode_prob_mirror_mode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ProbabilityRelay.py | 0.605916 | 0.272481 | ProbabilityRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct65 import UnknownStruct65
@dataclasses.dataclass()
class BloomEffect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct65: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BLME'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x88.\x9fG') # 0x882e9f47
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct65.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct65=UnknownStruct65.from_json(data['unknown_struct65']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct65': self.unknown_struct65.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct65(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x882e9f47: ('unknown_struct65', _decode_unknown_struct65),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BloomEffect.py | 0.624064 | 0.368434 | BloomEffect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct184 import UnknownStruct184
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct185 import UnknownStruct185
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 IslandArea(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
area_name: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
name: str = dataclasses.field(default='')
area_type: enums.AreaType = dataclasses.field(default=enums.AreaType.Unknown1)
unknown_struct184: UnknownStruct184 = dataclasses.field(default_factory=UnknownStruct184)
unknown_struct185: UnknownStruct185 = dataclasses.field(default_factory=UnknownStruct185)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ISAR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\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'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\x83\xdd1') # 0x3b83dd31
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.area_name))
data.write(b'j\x02\xf0_') # 0x6a02f05f
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'(\xe2\x9f\x9b') # 0x28e29f9b
data.write(b'\x00\x04') # size
self.area_type.to_stream(data)
data.write(b'\xdfi)g') # 0xdf692967
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct184.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0fr#W') # 0xf722357
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct185.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
model=data['model'],
collision_model=data['collision_model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
area_name=data['area_name'],
name=data['name'],
area_type=enums.AreaType.from_json(data['area_type']),
unknown_struct184=UnknownStruct184.from_json(data['unknown_struct184']),
unknown_struct185=UnknownStruct185.from_json(data['unknown_struct185']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'character_animation_information': self.character_animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'area_name': self.area_name,
'name': self.name,
'area_type': self.area_type.to_json(),
'unknown_struct184': self.unknown_struct184.to_json(),
'unknown_struct185': self.unknown_struct185.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_area_name(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_area_type(data: typing.BinaryIO, property_size: int):
return enums.AreaType.from_stream(data)
def _decode_unknown_struct184(data: typing.BinaryIO, property_size: int):
return UnknownStruct184.from_stream(data, property_size)
def _decode_unknown_struct185(data: typing.BinaryIO, property_size: int):
return UnknownStruct185.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0x3b83dd31: ('area_name', _decode_area_name),
0x6a02f05f: ('name', _decode_name),
0x28e29f9b: ('area_type', _decode_area_type),
0xdf692967: ('unknown_struct184', _decode_unknown_struct184),
0xf722357: ('unknown_struct185', _decode_unknown_struct185),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/IslandArea.py | 0.536313 | 0.282611 | IslandArea.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TimeAttackEOLDisplay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TEOL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TimeAttackEOLDisplay.py | 0.601359 | 0.358578 | TimeAttackEOLDisplay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.RotationSplines import RotationSplines
from retro_data_structures.properties.dkc_returns.archetypes.TranslationSplines import TranslationSplines
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 FactorySwitch(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
case_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
indicator_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
switch_state: bool = dataclasses.field(default=False)
switch_delay: float = dataclasses.field(default=0.6000000238418579)
rotation_controls: RotationSplines = dataclasses.field(default_factory=RotationSplines)
translation_control: TranslationSplines = dataclasses.field(default_factory=TranslationSplines)
toggle_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
reset_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x25c9c68f: bool = dataclasses.field(default=False)
unknown_0x10e79562: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x7357fbac: bool = dataclasses.field(default=False)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FSWC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\r') # 13 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l\xa4S\xb1') # 0x6ca453b1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.case_model))
data.write(b'\xb6\xd3L\xbe') # 0xb6d34cbe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.indicator_model))
data.write(b'f\xe6N\xba') # 0x66e64eba
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.switch_state))
data.write(b'\x8a\x1f\xd6a') # 0x8a1fd661
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.switch_delay))
data.write(b'\xef\xe4\xeaW') # 0xefe4ea57
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotation_controls.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'i"g\xea') # 0x692267ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.translation_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xf9oT') # 0x36f96f54
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.toggle_sound))
data.write(b'FQY\xa3') # 0x465159a3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.reset_sound))
data.write(b'%\xc9\xc6\x8f') # 0x25c9c68f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x25c9c68f))
data.write(b'\x10\xe7\x95b') # 0x10e79562
data.write(b'\x00\x0c') # size
self.unknown_0x10e79562.to_stream(data)
data.write(b'sW\xfb\xac') # 0x7357fbac
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7357fbac))
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
case_model=data['case_model'],
indicator_model=data['indicator_model'],
switch_state=data['switch_state'],
switch_delay=data['switch_delay'],
rotation_controls=RotationSplines.from_json(data['rotation_controls']),
translation_control=TranslationSplines.from_json(data['translation_control']),
toggle_sound=data['toggle_sound'],
reset_sound=data['reset_sound'],
unknown_0x25c9c68f=data['unknown_0x25c9c68f'],
unknown_0x10e79562=Vector.from_json(data['unknown_0x10e79562']),
unknown_0x7357fbac=data['unknown_0x7357fbac'],
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'case_model': self.case_model,
'indicator_model': self.indicator_model,
'switch_state': self.switch_state,
'switch_delay': self.switch_delay,
'rotation_controls': self.rotation_controls.to_json(),
'translation_control': self.translation_control.to_json(),
'toggle_sound': self.toggle_sound,
'reset_sound': self.reset_sound,
'unknown_0x25c9c68f': self.unknown_0x25c9c68f,
'unknown_0x10e79562': self.unknown_0x10e79562.to_json(),
'unknown_0x7357fbac': self.unknown_0x7357fbac,
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_case_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_indicator_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_switch_state(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_switch_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_controls(data: typing.BinaryIO, property_size: int):
return RotationSplines.from_stream(data, property_size)
def _decode_translation_control(data: typing.BinaryIO, property_size: int):
return TranslationSplines.from_stream(data, property_size)
def _decode_toggle_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_reset_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x25c9c68f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x10e79562(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x7357fbac(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6ca453b1: ('case_model', _decode_case_model),
0xb6d34cbe: ('indicator_model', _decode_indicator_model),
0x66e64eba: ('switch_state', _decode_switch_state),
0x8a1fd661: ('switch_delay', _decode_switch_delay),
0xefe4ea57: ('rotation_controls', _decode_rotation_controls),
0x692267ea: ('translation_control', _decode_translation_control),
0x36f96f54: ('toggle_sound', _decode_toggle_sound),
0x465159a3: ('reset_sound', _decode_reset_sound),
0x25c9c68f: ('unknown_0x25c9c68f', _decode_unknown_0x25c9c68f),
0x10e79562: ('unknown_0x10e79562', _decode_unknown_0x10e79562),
0x7357fbac: ('unknown_0x7357fbac', _decode_unknown_0x7357fbac),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/FactorySwitch.py | 0.536313 | 0.311558 | FactorySwitch.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SwingRopeData import SwingRopeData
@dataclasses.dataclass()
class SwingRope(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
swing_rope_data: SwingRopeData = dataclasses.field(default_factory=SwingRopeData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ROPE'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'da\xcc\xd6') # 0x6461ccd6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swing_rope_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
swing_rope_data=SwingRopeData.from_json(data['swing_rope_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'swing_rope_data': self.swing_rope_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_swing_rope_data(data: typing.BinaryIO, property_size: int):
return SwingRopeData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x6461ccd6: ('swing_rope_data', _decode_swing_rope_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SwingRope.py | 0.680985 | 0.322059 | SwingRope.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct95 import UnknownStruct95
@dataclasses.dataclass()
class ForestBoss(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct95: UnknownStruct95 = dataclasses.field(default_factory=UnknownStruct95)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOBS'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ForestBoss.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\xccY!') # 0x4acc5921
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct95.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct95=UnknownStruct95.from_json(data['unknown_struct95']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct95': self.unknown_struct95.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_unknown_struct95(data: typing.BinaryIO, property_size: int):
return UnknownStruct95.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x4acc5921: ('unknown_struct95', _decode_unknown_struct95),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ForestBoss.py | 0.632616 | 0.349061 | ForestBoss.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct240 import UnknownStruct240
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MoleTrainManager(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fsmc: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
unknown_struct240: UnknownStruct240 = dataclasses.field(default_factory=UnknownStruct240)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MOLM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MoleTrain.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17I@[') # 0x1749405b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fsmc))
data.write(b'\xea\xcc~\xd2') # 0xeacc7ed2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct240.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
fsmc=data['fsmc'],
unknown_struct240=UnknownStruct240.from_json(data['unknown_struct240']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'fsmc': self.fsmc,
'unknown_struct240': self.unknown_struct240.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_fsmc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct240(data: typing.BinaryIO, property_size: int):
return UnknownStruct240.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x1749405b: ('fsmc', _decode_fsmc),
0xeacc7ed2: ('unknown_struct240', _decode_unknown_struct240),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MoleTrainManager.py | 0.637369 | 0.312895 | MoleTrainManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileBounceData import ProjectileBounceData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileCollisionData import ProjectileCollisionData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileData import ProjectileData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileMotionData import ProjectileMotionData
from retro_data_structures.properties.dkc_returns.archetypes.ProjectileRenderData import ProjectileRenderData
@dataclasses.dataclass()
class Projectile(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
projectile_data: ProjectileData = dataclasses.field(default_factory=ProjectileData)
projectile_render_data: ProjectileRenderData = dataclasses.field(default_factory=ProjectileRenderData)
projectile_collision_data: ProjectileCollisionData = dataclasses.field(default_factory=ProjectileCollisionData)
projectile_motion_data: ProjectileMotionData = dataclasses.field(default_factory=ProjectileMotionData)
can_bounce: bool = dataclasses.field(default=False)
projectile_bounce_data: ProjectileBounceData = dataclasses.field(default_factory=ProjectileBounceData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PROJ'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa5\xcc)\x82') # 0xa5cc2982
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd9\r\xab\t') # 0xd90dab09
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_render_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'X\xd9x_') # 0x58d9785f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_collision_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x90\xdc\xef\x98') # 0x90dcef98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_motion_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xccB\x84\xa2') # 0xcc4284a2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_bounce))
data.write(b'P\xa7\xe9K') # 0x50a7e94b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_bounce_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
projectile_data=ProjectileData.from_json(data['projectile_data']),
projectile_render_data=ProjectileRenderData.from_json(data['projectile_render_data']),
projectile_collision_data=ProjectileCollisionData.from_json(data['projectile_collision_data']),
projectile_motion_data=ProjectileMotionData.from_json(data['projectile_motion_data']),
can_bounce=data['can_bounce'],
projectile_bounce_data=ProjectileBounceData.from_json(data['projectile_bounce_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'projectile_data': self.projectile_data.to_json(),
'projectile_render_data': self.projectile_render_data.to_json(),
'projectile_collision_data': self.projectile_collision_data.to_json(),
'projectile_motion_data': self.projectile_motion_data.to_json(),
'can_bounce': self.can_bounce,
'projectile_bounce_data': self.projectile_bounce_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_projectile_data(data: typing.BinaryIO, property_size: int):
return ProjectileData.from_stream(data, property_size)
def _decode_projectile_render_data(data: typing.BinaryIO, property_size: int):
return ProjectileRenderData.from_stream(data, property_size)
def _decode_projectile_collision_data(data: typing.BinaryIO, property_size: int):
return ProjectileCollisionData.from_stream(data, property_size)
def _decode_projectile_motion_data(data: typing.BinaryIO, property_size: int):
return ProjectileMotionData.from_stream(data, property_size)
def _decode_can_bounce(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_projectile_bounce_data(data: typing.BinaryIO, property_size: int):
return ProjectileBounceData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa5cc2982: ('projectile_data', _decode_projectile_data),
0xd90dab09: ('projectile_render_data', _decode_projectile_render_data),
0x58d9785f: ('projectile_collision_data', _decode_projectile_collision_data),
0x90dcef98: ('projectile_motion_data', _decode_projectile_motion_data),
0xcc4284a2: ('can_bounce', _decode_can_bounce),
0x50a7e94b: ('projectile_bounce_data', _decode_projectile_bounce_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Projectile.py | 0.570212 | 0.395076 | Projectile.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct182 import UnknownStruct182
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct183 import UnknownStruct183
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct28 import UnknownStruct28
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct36 import UnknownStruct36
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class IslandHUD(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
cursor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
disabled_cursor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
secondary_cursor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_struct182: UnknownStruct182 = dataclasses.field(default_factory=UnknownStruct182)
unknown_struct36: UnknownStruct36 = dataclasses.field(default_factory=UnknownStruct36)
unknown_struct183: UnknownStruct183 = dataclasses.field(default_factory=UnknownStruct183)
unknown_struct28_0xc68bc9ec: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct28_0x6bdd8b7a: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct28_0xcc53c738: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct28_0xbcf93a2a: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct28_0x6549e3f9: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'IHUD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\x94\x80j') # 0xf94806a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cursor_model))
data.write(b'\xd0/\xb1\xa1') # 0xd02fb1a1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.disabled_cursor_model))
data.write(b'\xa7@e\xce') # 0xa74065ce
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.secondary_cursor_model))
data.write(b'\x17C\xb7p') # 0x1743b770
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct182.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'?\x88\xe9\x00') # 0x3f88e900
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct36.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb|\x1b\xf2') # 0xeb7c1bf2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct183.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\x8b\xc9\xec') # 0xc68bc9ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0xc68bc9ec.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k\xdd\x8bz') # 0x6bdd8b7a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0x6bdd8b7a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xccS\xc78') # 0xcc53c738
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0xcc53c738.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\xf9:*') # 0xbcf93a2a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0xbcf93a2a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'eI\xe3\xf9') # 0x6549e3f9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0x6549e3f9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
cursor_model=data['cursor_model'],
disabled_cursor_model=data['disabled_cursor_model'],
secondary_cursor_model=data['secondary_cursor_model'],
unknown_struct182=UnknownStruct182.from_json(data['unknown_struct182']),
unknown_struct36=UnknownStruct36.from_json(data['unknown_struct36']),
unknown_struct183=UnknownStruct183.from_json(data['unknown_struct183']),
unknown_struct28_0xc68bc9ec=UnknownStruct28.from_json(data['unknown_struct28_0xc68bc9ec']),
unknown_struct28_0x6bdd8b7a=UnknownStruct28.from_json(data['unknown_struct28_0x6bdd8b7a']),
unknown_struct28_0xcc53c738=UnknownStruct28.from_json(data['unknown_struct28_0xcc53c738']),
unknown_struct28_0xbcf93a2a=UnknownStruct28.from_json(data['unknown_struct28_0xbcf93a2a']),
unknown_struct28_0x6549e3f9=UnknownStruct28.from_json(data['unknown_struct28_0x6549e3f9']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'cursor_model': self.cursor_model,
'disabled_cursor_model': self.disabled_cursor_model,
'secondary_cursor_model': self.secondary_cursor_model,
'unknown_struct182': self.unknown_struct182.to_json(),
'unknown_struct36': self.unknown_struct36.to_json(),
'unknown_struct183': self.unknown_struct183.to_json(),
'unknown_struct28_0xc68bc9ec': self.unknown_struct28_0xc68bc9ec.to_json(),
'unknown_struct28_0x6bdd8b7a': self.unknown_struct28_0x6bdd8b7a.to_json(),
'unknown_struct28_0xcc53c738': self.unknown_struct28_0xcc53c738.to_json(),
'unknown_struct28_0xbcf93a2a': self.unknown_struct28_0xbcf93a2a.to_json(),
'unknown_struct28_0x6549e3f9': self.unknown_struct28_0x6549e3f9.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_cursor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_disabled_cursor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_secondary_cursor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct182(data: typing.BinaryIO, property_size: int):
return UnknownStruct182.from_stream(data, property_size)
def _decode_unknown_struct36(data: typing.BinaryIO, property_size: int):
return UnknownStruct36.from_stream(data, property_size)
def _decode_unknown_struct183(data: typing.BinaryIO, property_size: int):
return UnknownStruct183.from_stream(data, property_size)
def _decode_unknown_struct28_0xc68bc9ec(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct28_0x6bdd8b7a(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct28_0xcc53c738(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct28_0xbcf93a2a(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct28_0x6549e3f9(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf94806a: ('cursor_model', _decode_cursor_model),
0xd02fb1a1: ('disabled_cursor_model', _decode_disabled_cursor_model),
0xa74065ce: ('secondary_cursor_model', _decode_secondary_cursor_model),
0x1743b770: ('unknown_struct182', _decode_unknown_struct182),
0x3f88e900: ('unknown_struct36', _decode_unknown_struct36),
0xeb7c1bf2: ('unknown_struct183', _decode_unknown_struct183),
0xc68bc9ec: ('unknown_struct28_0xc68bc9ec', _decode_unknown_struct28_0xc68bc9ec),
0x6bdd8b7a: ('unknown_struct28_0x6bdd8b7a', _decode_unknown_struct28_0x6bdd8b7a),
0xcc53c738: ('unknown_struct28_0xcc53c738', _decode_unknown_struct28_0xcc53c738),
0xbcf93a2a: ('unknown_struct28_0xbcf93a2a', _decode_unknown_struct28_0xbcf93a2a),
0x6549e3f9: ('unknown_struct28_0x6549e3f9', _decode_unknown_struct28_0x6549e3f9),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/IslandHUD.py | 0.513181 | 0.255503 | IslandHUD.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct19 import UnknownStruct19
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct20 import UnknownStruct20
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 AreaNode(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
start_hidden: bool = dataclasses.field(default=False)
play_cinematic: bool = dataclasses.field(default=False)
unknown_0xa6f8611c: bool = dataclasses.field(default=False)
node_type: enums.NodeType = dataclasses.field(default=enums.NodeType.Stage)
name: str = dataclasses.field(default='')
world_name: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
area_name: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
sort_order: int = dataclasses.field(default=0)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
unknown_0x33cf5665: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0xb7cd213c: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x9f93bc3f: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
world_level: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
unknown_struct19: UnknownStruct19 = dataclasses.field(default_factory=UnknownStruct19)
unknown_struct20: UnknownStruct20 = dataclasses.field(default_factory=UnknownStruct20)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ARNO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x14') # 20 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'M\xef{\x9b') # 0x4def7b9b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_hidden))
data.write(b'\xf1\xae/\x13') # 0xf1ae2f13
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.play_cinematic))
data.write(b'\xa6\xf8a\x1c') # 0xa6f8611c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa6f8611c))
data.write(b'\x8d:\xb3\x14') # 0x8d3ab314
data.write(b'\x00\x04') # size
self.node_type.to_stream(data)
data.write(b'j\x02\xf0_') # 0x6a02f05f
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'sv1\xad') # 0x737631ad
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.world_name))
data.write(b';\x83\xdd1') # 0x3b83dd31
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.area_name))
data.write(b'0\xcb\xdbh') # 0x30cbdb68
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sort_order))
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'3\xcfVe') # 0x33cf5665
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x33cf5665))
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'\xb7\xcd!<') # 0xb7cd213c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb7cd213c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9f\x93\xbc?') # 0x9f93bc3f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x9f93bc3f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'jx\x9b\xe3') # 0x6a789be3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.world_level))
data.write(b'\xa9\xd2\x9e2') # 0xa9d29e32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct19.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\x96>\x8a') # 0x86963e8a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct20.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
start_hidden=data['start_hidden'],
play_cinematic=data['play_cinematic'],
unknown_0xa6f8611c=data['unknown_0xa6f8611c'],
node_type=enums.NodeType.from_json(data['node_type']),
name=data['name'],
world_name=data['world_name'],
area_name=data['area_name'],
sort_order=data['sort_order'],
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
collision_model=data['collision_model'],
unknown_0x33cf5665=data['unknown_0x33cf5665'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
unknown_0xb7cd213c=AnimationParameters.from_json(data['unknown_0xb7cd213c']),
unknown_0x9f93bc3f=AnimationParameters.from_json(data['unknown_0x9f93bc3f']),
actor_information=ActorParameters.from_json(data['actor_information']),
world_level=data['world_level'],
unknown_struct19=UnknownStruct19.from_json(data['unknown_struct19']),
unknown_struct20=UnknownStruct20.from_json(data['unknown_struct20']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'start_hidden': self.start_hidden,
'play_cinematic': self.play_cinematic,
'unknown_0xa6f8611c': self.unknown_0xa6f8611c,
'node_type': self.node_type.to_json(),
'name': self.name,
'world_name': self.world_name,
'area_name': self.area_name,
'sort_order': self.sort_order,
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'collision_model': self.collision_model,
'unknown_0x33cf5665': self.unknown_0x33cf5665,
'character_animation_information': self.character_animation_information.to_json(),
'unknown_0xb7cd213c': self.unknown_0xb7cd213c.to_json(),
'unknown_0x9f93bc3f': self.unknown_0x9f93bc3f.to_json(),
'actor_information': self.actor_information.to_json(),
'world_level': self.world_level,
'unknown_struct19': self.unknown_struct19.to_json(),
'unknown_struct20': self.unknown_struct20.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_start_hidden(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_play_cinematic(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa6f8611c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_node_type(data: typing.BinaryIO, property_size: int):
return enums.NodeType.from_stream(data)
def _decode_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_world_name(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_area_name(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sort_order(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x33cf5665(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0xb7cd213c(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x9f93bc3f(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_world_level(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_struct19(data: typing.BinaryIO, property_size: int):
return UnknownStruct19.from_stream(data, property_size)
def _decode_unknown_struct20(data: typing.BinaryIO, property_size: int):
return UnknownStruct20.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x4def7b9b: ('start_hidden', _decode_start_hidden),
0xf1ae2f13: ('play_cinematic', _decode_play_cinematic),
0xa6f8611c: ('unknown_0xa6f8611c', _decode_unknown_0xa6f8611c),
0x8d3ab314: ('node_type', _decode_node_type),
0x6a02f05f: ('name', _decode_name),
0x737631ad: ('world_name', _decode_world_name),
0x3b83dd31: ('area_name', _decode_area_name),
0x30cbdb68: ('sort_order', _decode_sort_order),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xfc966dc: ('collision_model', _decode_collision_model),
0x33cf5665: ('unknown_0x33cf5665', _decode_unknown_0x33cf5665),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xb7cd213c: ('unknown_0xb7cd213c', _decode_unknown_0xb7cd213c),
0x9f93bc3f: ('unknown_0x9f93bc3f', _decode_unknown_0x9f93bc3f),
0x7e397fed: ('actor_information', _decode_actor_information),
0x6a789be3: ('world_level', _decode_world_level),
0xa9d29e32: ('unknown_struct19', _decode_unknown_struct19),
0x86963e8a: ('unknown_struct20', _decode_unknown_struct20),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AreaNode.py | 0.560854 | 0.194559 | AreaNode.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct84 import UnknownStruct84
@dataclasses.dataclass()
class CameraModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct84: UnknownStruct84 = dataclasses.field(default_factory=UnknownStruct84)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CMOD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10j\xb5\x81') # 0x106ab581
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct84.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct84=UnknownStruct84.from_json(data['unknown_struct84']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct84': self.unknown_struct84.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct84(data: typing.BinaryIO, property_size: int):
return UnknownStruct84.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x106ab581: ('unknown_struct84', _decode_unknown_struct84),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CameraModifier.py | 0.628863 | 0.366505 | CameraModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.GroundPoundDetectorData import GroundPoundDetectorData
@dataclasses.dataclass()
class GroundPoundDetector(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
ground_pound_detector_data: GroundPoundDetectorData = dataclasses.field(default_factory=GroundPoundDetectorData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GPDT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe8\t\xb3\xa0') # 0xe809b3a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ground_pound_detector_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
ground_pound_detector_data=GroundPoundDetectorData.from_json(data['ground_pound_detector_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'ground_pound_detector_data': self.ground_pound_detector_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_ground_pound_detector_data(data: typing.BinaryIO, property_size: int):
return GroundPoundDetectorData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe809b3a0: ('ground_pound_detector_data', _decode_ground_pound_detector_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GroundPoundDetector.py | 0.635788 | 0.374333 | GroundPoundDetector.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct243 import UnknownStruct243
@dataclasses.dataclass()
class PilotChicken(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct243: UnknownStruct243 = dataclasses.field(default_factory=UnknownStruct243)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PCHK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_RobotChicken.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%?\xa4\xef') # 0x253fa4ef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct243.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct243=UnknownStruct243.from_json(data['unknown_struct243']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct243': self.unknown_struct243.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_unknown_struct243(data: typing.BinaryIO, property_size: int):
return UnknownStruct243.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x253fa4ef: ('unknown_struct243', _decode_unknown_struct243),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PilotChicken.py | 0.656218 | 0.332676 | PilotChicken.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.TextProperties import TextProperties
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Subtitles(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
text_position_x: int = dataclasses.field(default=0)
text_position_y: int = dataclasses.field(default=100)
japan_text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
japan_text_position_x: int = dataclasses.field(default=0)
japan_text_position_y: int = dataclasses.field(default=100)
string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
initial_string_index: int = dataclasses.field(default=0)
fade_in_time: float = dataclasses.field(default=0.0)
fade_out_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SUBT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0T>f') # 0xe0543e66
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.text_properties.to_stream(data, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3:\x87\xc7') # 0xc33a87c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_x))
data.write(b'{\x86\xe0\xa2') # 0x7b86e0a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_y))
data.write(b'\xc8\xe4A\xfa') # 0xc8e441fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.japan_text_properties.to_stream(data, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S\xa7\xf7\xa7') # 0x53a7f7a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_x))
data.write(b'\xeb\x1b\x90\xc2') # 0xeb1b90c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_y))
data.write(b'\xfd\x95\xed*') # 0xfd95ed2a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.string_table))
data.write(b'l\xe4f\x89') # 0x6ce46689
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_string_index))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
text_properties=TextProperties.from_json(data['text_properties']),
text_position_x=data['text_position_x'],
text_position_y=data['text_position_y'],
japan_text_properties=TextProperties.from_json(data['japan_text_properties']),
japan_text_position_x=data['japan_text_position_x'],
japan_text_position_y=data['japan_text_position_y'],
string_table=data['string_table'],
initial_string_index=data['initial_string_index'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'text_properties': self.text_properties.to_json(),
'text_position_x': self.text_position_x,
'text_position_y': self.text_position_y,
'japan_text_properties': self.japan_text_properties.to_json(),
'japan_text_position_x': self.japan_text_position_x,
'japan_text_position_y': self.japan_text_position_y,
'string_table': self.string_table,
'initial_string_index': self.initial_string_index,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
def _decode_text_position_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
def _decode_japan_text_position_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_initial_string_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe0543e66: ('text_properties', _decode_text_properties),
0xc33a87c7: ('text_position_x', _decode_text_position_x),
0x7b86e0a2: ('text_position_y', _decode_text_position_y),
0xc8e441fa: ('japan_text_properties', _decode_japan_text_properties),
0x53a7f7a7: ('japan_text_position_x', _decode_japan_text_position_x),
0xeb1b90c2: ('japan_text_position_y', _decode_japan_text_position_y),
0xfd95ed2a: ('string_table', _decode_string_table),
0x6ce46689: ('initial_string_index', _decode_initial_string_index),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Subtitles.py | 0.589007 | 0.27623 | Subtitles.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct271 import UnknownStruct271
@dataclasses.dataclass()
class TarPit(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct271: UnknownStruct271 = dataclasses.field(default_factory=UnknownStruct271)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TARP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'=+~\xb9') # 0x3d2b7eb9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct271.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct271=UnknownStruct271.from_json(data['unknown_struct271']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct271': self.unknown_struct271.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct271(data: typing.BinaryIO, property_size: int):
return UnknownStruct271.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3d2b7eb9: ('unknown_struct271', _decode_unknown_struct271),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TarPit.py | 0.622345 | 0.358493 | TarPit.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SplinePathNetwork(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPNW'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ForestBoss.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SplinePathNetwork.py | 0.61057 | 0.362377 | SplinePathNetwork.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct96 import UnknownStruct96
@dataclasses.dataclass()
class GenericCreatureGroup(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct96: UnknownStruct96 = dataclasses.field(default_factory=UnknownStruct96)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GCGP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\x1a\xd7\x12') # 0xed1ad712
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct96.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct96=UnknownStruct96.from_json(data['unknown_struct96']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct96': self.unknown_struct96.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct96(data: typing.BinaryIO, property_size: int):
return UnknownStruct96.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xed1ad712: ('unknown_struct96', _decode_unknown_struct96),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GenericCreatureGroup.py | 0.625552 | 0.351033 | GenericCreatureGroup.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.dkc_returns.archetypes.TriggerInfo import TriggerInfo
@dataclasses.dataclass()
class DamageableTriggerOrientated(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
invulnerable: bool = dataclasses.field(default=False)
damage_originator: enums.DamageableTriggerEnum = dataclasses.field(default=enums.DamageableTriggerEnum.Unknown1)
trigger_properties: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DTRO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'{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'fR\xbd\xd7') # 0x6652bdd7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.invulnerable))
data.write(b'\x8b\x9d!#') # 0x8b9d2123
data.write(b'\x00\x04') # size
self.damage_originator.to_stream(data)
data.write(b'\xbb\xfe\xe9>') # 0xbbfee93e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
invulnerable=data['invulnerable'],
damage_originator=enums.DamageableTriggerEnum.from_json(data['damage_originator']),
trigger_properties=TriggerInfo.from_json(data['trigger_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'invulnerable': self.invulnerable,
'damage_originator': self.damage_originator.to_json(),
'trigger_properties': self.trigger_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_invulnerable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damage_originator(data: typing.BinaryIO, property_size: int):
return enums.DamageableTriggerEnum.from_stream(data)
def _decode_trigger_properties(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x6652bdd7: ('invulnerable', _decode_invulnerable),
0x8b9d2123: ('damage_originator', _decode_damage_originator),
0xbbfee93e: ('trigger_properties', _decode_trigger_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DamageableTriggerOrientated.py | 0.608594 | 0.357652 | DamageableTriggerOrientated.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct299 import UnknownStruct299
@dataclasses.dataclass()
class WorldAttributes(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct299: UnknownStruct299 = dataclasses.field(default_factory=UnknownStruct299)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WLDA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xe8k\xfb') # 0xeae86bfb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct299.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct299=UnknownStruct299.from_json(data['unknown_struct299']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct299': self.unknown_struct299.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct299(data: typing.BinaryIO, property_size: int):
return UnknownStruct299.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xeae86bfb: ('unknown_struct299', _decode_unknown_struct299),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/WorldAttributes.py | 0.626467 | 0.359955 | WorldAttributes.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.CableProperties import CableProperties
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Cable(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
cable_properties: CableProperties = dataclasses.field(default_factory=CableProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CABL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptCable.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\xb9=\xb9') # 0x93b93db9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cable_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
cable_properties=CableProperties.from_json(data['cable_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'cable_properties': self.cable_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_cable_properties(data: typing.BinaryIO, property_size: int):
return CableProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x93b93db9: ('cable_properties', _decode_cable_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Cable.py | 0.691185 | 0.316316 | Cable.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct259 import UnknownStruct259
@dataclasses.dataclass()
class RobotChicken(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct259: UnknownStruct259 = dataclasses.field(default_factory=UnknownStruct259)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RCHK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_RobotChicken.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9e;W\x0e') # 0x9e3b570e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct259.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct259=UnknownStruct259.from_json(data['unknown_struct259']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct259': self.unknown_struct259.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_unknown_struct259(data: typing.BinaryIO, property_size: int):
return UnknownStruct259.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x9e3b570e: ('unknown_struct259', _decode_unknown_struct259),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RobotChicken.py | 0.644673 | 0.342901 | RobotChicken.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class SplinePath(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
is_secondary_path: bool = dataclasses.field(default=False)
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
editor_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPPA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\xb9+\x9e') # 0x93b92b9e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_secondary_path))
data.write(b' \t\x1bT') # 0x20091b54
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xdd\x86\xe2') # 0xdd86e2
data.write(b'\x00\x10') # size
self.editor_color.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
is_secondary_path=data['is_secondary_path'],
spline_type=SplineType.from_json(data['spline_type']),
editor_color=Color.from_json(data['editor_color']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'is_secondary_path': self.is_secondary_path,
'spline_type': self.spline_type.to_json(),
'editor_color': self.editor_color.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_is_secondary_path(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_editor_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x93b92b9e: ('is_secondary_path', _decode_is_secondary_path),
0x20091b54: ('spline_type', _decode_spline_type),
0xdd86e2: ('editor_color', _decode_editor_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SplinePath.py | 0.70028 | 0.352257 | SplinePath.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct265 import UnknownStruct265
@dataclasses.dataclass()
class ReactiveScale(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct265: UnknownStruct265 = dataclasses.field(default_factory=UnknownStruct265)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RSCL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6jR$') # 0x366a5224
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct265.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct265=UnknownStruct265.from_json(data['unknown_struct265']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct265': self.unknown_struct265.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct265(data: typing.BinaryIO, property_size: int):
return UnknownStruct265.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x366a5224: ('unknown_struct265', _decode_unknown_struct265),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ReactiveScale.py | 0.624408 | 0.35768 | ReactiveScale.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.RotationSplines import RotationSplines
from retro_data_structures.properties.dkc_returns.archetypes.ScaleSplines import ScaleSplines
from retro_data_structures.properties.dkc_returns.archetypes.TranslationSplines import TranslationSplines
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class ActorTransform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_actor_transform: int = dataclasses.field(default=20)
duration: float = dataclasses.field(default=10.0)
initial_time: float = dataclasses.field(default=0.0)
rotation_controls: RotationSplines = dataclasses.field(default_factory=RotationSplines)
scale_controls: ScaleSplines = dataclasses.field(default_factory=ScaleSplines)
translation_control: TranslationSplines = dataclasses.field(default_factory=TranslationSplines)
path_position: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ATRN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xcev\x89') # 0xc6ce7689
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_actor_transform))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\xa5u=R') # 0xa5753d52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_time))
data.write(b'\xef\xe4\xeaW') # 0xefe4ea57
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotation_controls.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/~\xc0\xa2') # 0x2f7ec0a2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scale_controls.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'i"g\xea') # 0x692267ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.translation_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\xb8\xaa\xca') # 0x51b8aaca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_position.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_actor_transform=data['flags_actor_transform'],
duration=data['duration'],
initial_time=data['initial_time'],
rotation_controls=RotationSplines.from_json(data['rotation_controls']),
scale_controls=ScaleSplines.from_json(data['scale_controls']),
translation_control=TranslationSplines.from_json(data['translation_control']),
path_position=Spline.from_json(data['path_position']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_actor_transform': self.flags_actor_transform,
'duration': self.duration,
'initial_time': self.initial_time,
'rotation_controls': self.rotation_controls.to_json(),
'scale_controls': self.scale_controls.to_json(),
'translation_control': self.translation_control.to_json(),
'path_position': self.path_position.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_actor_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initial_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_controls(data: typing.BinaryIO, property_size: int):
return RotationSplines.from_stream(data, property_size)
def _decode_scale_controls(data: typing.BinaryIO, property_size: int):
return ScaleSplines.from_stream(data, property_size)
def _decode_translation_control(data: typing.BinaryIO, property_size: int):
return TranslationSplines.from_stream(data, property_size)
def _decode_path_position(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc6ce7689: ('flags_actor_transform', _decode_flags_actor_transform),
0x8b51e23f: ('duration', _decode_duration),
0xa5753d52: ('initial_time', _decode_initial_time),
0xefe4ea57: ('rotation_controls', _decode_rotation_controls),
0x2f7ec0a2: ('scale_controls', _decode_scale_controls),
0x692267ea: ('translation_control', _decode_translation_control),
0x51b8aaca: ('path_position', _decode_path_position),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ActorTransform.py | 0.674801 | 0.422266 | ActorTransform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.CreditsData import CreditsData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CreditsScreen(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
credits_data: CreditsData = dataclasses.field(default_factory=CreditsData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CRED'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k\x9fk|') # 0x6b9f6b7c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.credits_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
credits_data=CreditsData.from_json(data['credits_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'credits_data': self.credits_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_credits_data(data: typing.BinaryIO, property_size: int):
return CreditsData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6b9f6b7c: ('credits_data', _decode_credits_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CreditsScreen.py | 0.613815 | 0.37014 | CreditsScreen.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RadialDamage(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
radius: float = dataclasses.field(default=15.0)
auto_action: bool = dataclasses.field(default=False)
auto_delete: bool = dataclasses.field(default=False)
originator: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RADD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'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'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'8\x8e]\xd3') # 0x388e5dd3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_action))
data.write(b'\xdb\x82l\xbe') # 0xdb826cbe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_delete))
data.write(b'\x9c\x95\x1f\xed') # 0x9c951fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.originator))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage=DamageInfo.from_json(data['damage']),
radius=data['radius'],
auto_action=data['auto_action'],
auto_delete=data['auto_delete'],
originator=data['originator'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
'radius': self.radius,
'auto_action': self.auto_action,
'auto_delete': self.auto_delete,
'originator': self.originator,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_action(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_delete(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_originator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x337f9524: ('damage', _decode_damage),
0x78c507eb: ('radius', _decode_radius),
0x388e5dd3: ('auto_action', _decode_auto_action),
0xdb826cbe: ('auto_delete', _decode_auto_delete),
0x9c951fed: ('originator', _decode_originator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RadialDamage.py | 0.609757 | 0.34563 | RadialDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.TriggerInfo import TriggerInfo
@dataclasses.dataclass()
class Trigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shape: int = dataclasses.field(default=1210786545) # Choice
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
fix_position_on_activate: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TRGR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\t\xec\xee\x0c') # 0x9ecee0c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shape))
data.write(b'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\xa4>\xef') # 0x66a43eef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fix_position_on_activate))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shape=data['shape'],
trigger=TriggerInfo.from_json(data['trigger']),
fix_position_on_activate=data['fix_position_on_activate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shape': self.shape,
'trigger': self.trigger.to_json(),
'fix_position_on_activate': self.fix_position_on_activate,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shape(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_fix_position_on_activate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x9ecee0c: ('shape', _decode_shape),
0x77a27411: ('trigger', _decode_trigger),
0x66a43eef: ('fix_position_on_activate', _decode_fix_position_on_activate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Trigger.py | 0.622 | 0.317109 | Trigger.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.CameraClip import CameraClip
from retro_data_structures.properties.dkc_returns.archetypes.CameraConstraints import CameraConstraints
from retro_data_structures.properties.dkc_returns.archetypes.CameraFieldOfView import CameraFieldOfView
from retro_data_structures.properties.dkc_returns.archetypes.CameraFraming import CameraFraming
from retro_data_structures.properties.dkc_returns.archetypes.CameraInterpolation import CameraInterpolation
from retro_data_structures.properties.dkc_returns.archetypes.CameraMotion import CameraMotion
from retro_data_structures.properties.dkc_returns.archetypes.CameraNavigation import CameraNavigation
from retro_data_structures.properties.dkc_returns.archetypes.CameraOrientation import CameraOrientation
from retro_data_structures.properties.dkc_returns.archetypes.CameraPosition import CameraPosition
from retro_data_structures.properties.dkc_returns.archetypes.CameraRotation import CameraRotation
from retro_data_structures.properties.dkc_returns.archetypes.CameraTracking import CameraTracking
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.InterpolationMethod import InterpolationMethod
@dataclasses.dataclass()
class CameraHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
priority: int = dataclasses.field(default=50)
timer: float = dataclasses.field(default=0.0)
flags_camera_hint: int = dataclasses.field(default=1610905732) # Flagset
constraints: CameraConstraints = dataclasses.field(default_factory=CameraConstraints)
tracking_behavior: CameraTracking = dataclasses.field(default_factory=CameraTracking)
position_behavior: CameraPosition = dataclasses.field(default_factory=CameraPosition)
camera_position: CameraPosition = dataclasses.field(default_factory=CameraPosition)
navigation_behavior: CameraNavigation = dataclasses.field(default_factory=CameraNavigation)
motion_behavior: CameraMotion = dataclasses.field(default_factory=CameraMotion)
orientation_behavior: CameraOrientation = dataclasses.field(default_factory=CameraOrientation)
rotation_behavior: CameraRotation = dataclasses.field(default_factory=CameraRotation)
field_of_view_behavior: CameraFieldOfView = dataclasses.field(default_factory=CameraFieldOfView)
framing_behavior: CameraFraming = dataclasses.field(default_factory=CameraFraming)
interpolation_behavior: CameraInterpolation = dataclasses.field(default_factory=CameraInterpolation)
clip_behavior: CameraClip = dataclasses.field(default_factory=CameraClip)
control_frame_interpolation: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CAMH'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x11') # 17 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'B\x08vP') # 0x42087650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.priority))
data.write(b'\x87GU.') # 0x8747552e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.timer))
data.write(b'!\xd7 \xa9') # 0x21d720a9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_camera_hint))
data.write(b'\x97\xa9?\x8f') # 0x97a93f8f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.constraints.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe8\xea\xaf\x0e') # 0xe8eaaf0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tracking_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1\xbd\\@') # 0xd1bd5c40
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.position_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'O,\xa3$') # 0x4f2ca324
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_position.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'K\xe3IK') # 0x4be3494b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.navigation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xc3\xe7u') # 0xebc3e775
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'e\xfc\x11\xff') # 0x65fc11ff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xa7\xc3\x8d') # 0xa7c38d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\x12j\xd1') # 0xfc126ad1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.field_of_view_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe3\x89yn') # 0xe389796e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.framing_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"vH'\xd4") # 0x764827d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.interpolation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd3il\x11') # 0xd3696c11
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.clip_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xd0\xd47') # 0x95d0d437
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.control_frame_interpolation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
priority=data['priority'],
timer=data['timer'],
flags_camera_hint=data['flags_camera_hint'],
constraints=CameraConstraints.from_json(data['constraints']),
tracking_behavior=CameraTracking.from_json(data['tracking_behavior']),
position_behavior=CameraPosition.from_json(data['position_behavior']),
camera_position=CameraPosition.from_json(data['camera_position']),
navigation_behavior=CameraNavigation.from_json(data['navigation_behavior']),
motion_behavior=CameraMotion.from_json(data['motion_behavior']),
orientation_behavior=CameraOrientation.from_json(data['orientation_behavior']),
rotation_behavior=CameraRotation.from_json(data['rotation_behavior']),
field_of_view_behavior=CameraFieldOfView.from_json(data['field_of_view_behavior']),
framing_behavior=CameraFraming.from_json(data['framing_behavior']),
interpolation_behavior=CameraInterpolation.from_json(data['interpolation_behavior']),
clip_behavior=CameraClip.from_json(data['clip_behavior']),
control_frame_interpolation=InterpolationMethod.from_json(data['control_frame_interpolation']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'priority': self.priority,
'timer': self.timer,
'flags_camera_hint': self.flags_camera_hint,
'constraints': self.constraints.to_json(),
'tracking_behavior': self.tracking_behavior.to_json(),
'position_behavior': self.position_behavior.to_json(),
'camera_position': self.camera_position.to_json(),
'navigation_behavior': self.navigation_behavior.to_json(),
'motion_behavior': self.motion_behavior.to_json(),
'orientation_behavior': self.orientation_behavior.to_json(),
'rotation_behavior': self.rotation_behavior.to_json(),
'field_of_view_behavior': self.field_of_view_behavior.to_json(),
'framing_behavior': self.framing_behavior.to_json(),
'interpolation_behavior': self.interpolation_behavior.to_json(),
'clip_behavior': self.clip_behavior.to_json(),
'control_frame_interpolation': self.control_frame_interpolation.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_priority(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_flags_camera_hint(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_constraints(data: typing.BinaryIO, property_size: int):
return CameraConstraints.from_stream(data, property_size)
def _decode_tracking_behavior(data: typing.BinaryIO, property_size: int):
return CameraTracking.from_stream(data, property_size)
def _decode_position_behavior(data: typing.BinaryIO, property_size: int):
return CameraPosition.from_stream(data, property_size)
def _decode_camera_position(data: typing.BinaryIO, property_size: int):
return CameraPosition.from_stream(data, property_size)
def _decode_navigation_behavior(data: typing.BinaryIO, property_size: int):
return CameraNavigation.from_stream(data, property_size)
def _decode_motion_behavior(data: typing.BinaryIO, property_size: int):
return CameraMotion.from_stream(data, property_size)
def _decode_orientation_behavior(data: typing.BinaryIO, property_size: int):
return CameraOrientation.from_stream(data, property_size)
def _decode_rotation_behavior(data: typing.BinaryIO, property_size: int):
return CameraRotation.from_stream(data, property_size)
def _decode_field_of_view_behavior(data: typing.BinaryIO, property_size: int):
return CameraFieldOfView.from_stream(data, property_size)
def _decode_framing_behavior(data: typing.BinaryIO, property_size: int):
return CameraFraming.from_stream(data, property_size)
def _decode_interpolation_behavior(data: typing.BinaryIO, property_size: int):
return CameraInterpolation.from_stream(data, property_size)
def _decode_clip_behavior(data: typing.BinaryIO, property_size: int):
return CameraClip.from_stream(data, property_size)
def _decode_control_frame_interpolation(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x42087650: ('priority', _decode_priority),
0x8747552e: ('timer', _decode_timer),
0x21d720a9: ('flags_camera_hint', _decode_flags_camera_hint),
0x97a93f8f: ('constraints', _decode_constraints),
0xe8eaaf0e: ('tracking_behavior', _decode_tracking_behavior),
0xd1bd5c40: ('position_behavior', _decode_position_behavior),
0x4f2ca324: ('camera_position', _decode_camera_position),
0x4be3494b: ('navigation_behavior', _decode_navigation_behavior),
0xebc3e775: ('motion_behavior', _decode_motion_behavior),
0x65fc11ff: ('orientation_behavior', _decode_orientation_behavior),
0xa7c38d: ('rotation_behavior', _decode_rotation_behavior),
0xfc126ad1: ('field_of_view_behavior', _decode_field_of_view_behavior),
0xe389796e: ('framing_behavior', _decode_framing_behavior),
0x764827d4: ('interpolation_behavior', _decode_interpolation_behavior),
0xd3696c11: ('clip_behavior', _decode_clip_behavior),
0x95d0d437: ('control_frame_interpolation', _decode_control_frame_interpolation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CameraHint.py | 0.629091 | 0.316812 | CameraHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class CameraFilterKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
filter_type: int = dataclasses.field(default=0)
filter_shape: int = dataclasses.field(default=0)
filter_stage: int = dataclasses.field(default=0)
which_filter_group: int = dataclasses.field(default=0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
interpolate_in_time: float = dataclasses.field(default=0.0)
interpolate_out_time: float = dataclasses.field(default=0.0)
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
prevent_pause_when_incremented: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FILT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'yu\xdb[') # 0x7975db5b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_type))
data.write(b'j>\x9a=') # 0x6a3e9a3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_shape))
data.write(b'X\xbd\xbd{') # 0x58bdbd7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_stage))
data.write(b'?\xdcK.') # 0x3fdc4b2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_filter_group))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\xab\xd4\x1a6') # 0xabd41a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_in_time))
data.write(b'>\xafx\xfe') # 0x3eaf78fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_out_time))
data.write(b'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x89\xf7\xf8\xc5') # 0x89f7f8c5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.prevent_pause_when_incremented))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
filter_type=data['filter_type'],
filter_shape=data['filter_shape'],
filter_stage=data['filter_stage'],
which_filter_group=data['which_filter_group'],
color=Color.from_json(data['color']),
interpolate_in_time=data['interpolate_in_time'],
interpolate_out_time=data['interpolate_out_time'],
texture=data['texture'],
model=data['model'],
prevent_pause_when_incremented=data['prevent_pause_when_incremented'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'filter_type': self.filter_type,
'filter_shape': self.filter_shape,
'filter_stage': self.filter_stage,
'which_filter_group': self.which_filter_group,
'color': self.color.to_json(),
'interpolate_in_time': self.interpolate_in_time,
'interpolate_out_time': self.interpolate_out_time,
'texture': self.texture,
'model': self.model,
'prevent_pause_when_incremented': self.prevent_pause_when_incremented,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_filter_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_filter_shape(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_filter_stage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_which_filter_group(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_interpolate_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_interpolate_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_prevent_pause_when_incremented(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7975db5b: ('filter_type', _decode_filter_type),
0x6a3e9a3d: ('filter_shape', _decode_filter_shape),
0x58bdbd7b: ('filter_stage', _decode_filter_stage),
0x3fdc4b2e: ('which_filter_group', _decode_which_filter_group),
0x37c7d09d: ('color', _decode_color),
0xabd41a36: ('interpolate_in_time', _decode_interpolate_in_time),
0x3eaf78fe: ('interpolate_out_time', _decode_interpolate_out_time),
0xd1f65872: ('texture', _decode_texture),
0xc27ffa8f: ('model', _decode_model),
0x89f7f8c5: ('prevent_pause_when_incremented', _decode_prevent_pause_when_incremented),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CameraFilterKeyframe.py | 0.612889 | 0.286219 | CameraFilterKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.CounterConditions import CounterConditions
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Counter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
initial_count: int = dataclasses.field(default=0)
max_count: int = dataclasses.field(default=4)
auto_reset: bool = dataclasses.field(default=False)
wrap: bool = dataclasses.field(default=False)
counter_conditions: CounterConditions = dataclasses.field(default_factory=CounterConditions)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CNTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x17\x9ao') # 0xfd179a6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_count))
data.write(b'[\x85\x15\x89') # 0x5b851589
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_count))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'\xf0v\xce\xf5') # 0xf076cef5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wrap))
data.write(b'\x9c\x1d3\xde') # 0x9c1d33de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.counter_conditions.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
initial_count=data['initial_count'],
max_count=data['max_count'],
auto_reset=data['auto_reset'],
wrap=data['wrap'],
counter_conditions=CounterConditions.from_json(data['counter_conditions']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'initial_count': self.initial_count,
'max_count': self.max_count,
'auto_reset': self.auto_reset,
'wrap': self.wrap,
'counter_conditions': self.counter_conditions.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_initial_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_auto_reset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wrap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_counter_conditions(data: typing.BinaryIO, property_size: int):
return CounterConditions.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfd179a6f: ('initial_count', _decode_initial_count),
0x5b851589: ('max_count', _decode_max_count),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0xf076cef5: ('wrap', _decode_wrap),
0x9c1d33de: ('counter_conditions', _decode_counter_conditions),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Counter.py | 0.608361 | 0.327736 | Counter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class GPTR(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GPTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GPTR.py | 0.606382 | 0.365259 | GPTR.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.TrackObjectModuleData import TrackObjectModuleData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct236 import UnknownStruct236
@dataclasses.dataclass()
class Mole(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct236: UnknownStruct236 = dataclasses.field(default_factory=UnknownStruct236)
track_object_module_data: TrackObjectModuleData = dataclasses.field(default_factory=TrackObjectModuleData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MOLE'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MoleTrain.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xccC\xcd\xed') # 0xcc43cded
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct236.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0b\x16\xce\xd2') # 0xb16ced2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.track_object_module_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct236=UnknownStruct236.from_json(data['unknown_struct236']),
track_object_module_data=TrackObjectModuleData.from_json(data['track_object_module_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct236': self.unknown_struct236.to_json(),
'track_object_module_data': self.track_object_module_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_unknown_struct236(data: typing.BinaryIO, property_size: int):
return UnknownStruct236.from_stream(data, property_size)
def _decode_track_object_module_data(data: typing.BinaryIO, property_size: int):
return TrackObjectModuleData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0xcc43cded: ('unknown_struct236', _decode_unknown_struct236),
0xb16ced2: ('track_object_module_data', _decode_track_object_module_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Mole.py | 0.676406 | 0.32857 | Mole.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class MEAT(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
audio_memory: int = dataclasses.field(default=5000)
particle_memory: int = dataclasses.field(default=5000)
unknown: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MEAT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaf(z ') # 0xaf287a20
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.audio_memory))
data.write(b'\xd7\xbd\x99\x04') # 0xd7bd9904
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.particle_memory))
data.write(b'\xbe\xf1w\xd6') # 0xbef177d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
audio_memory=data['audio_memory'],
particle_memory=data['particle_memory'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'audio_memory': self.audio_memory,
'particle_memory': self.particle_memory,
'unknown': self.unknown,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_audio_memory(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_particle_memory(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xaf287a20: ('audio_memory', _decode_audio_memory),
0xd7bd9904: ('particle_memory', _decode_particle_memory),
0xbef177d6: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MEAT.py | 0.646795 | 0.357119 | MEAT.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.ReactiveActorBehaviors import ReactiveActorBehaviors
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 ReactiveActor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
detection_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
detection_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
character: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
start_enabled: bool = dataclasses.field(default=True)
texture_set: int = dataclasses.field(default=0)
behaviors: ReactiveActorBehaviors = dataclasses.field(default_factory=ReactiveActorBehaviors)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'REAC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\t') # 9 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'lD\x7f\xf0') # 0x6c447ff0
data.write(b'\x00\x0c') # size
self.detection_box.to_stream(data)
data.write(b'=\xafS\x02') # 0x3daf5302
data.write(b'\x00\x0c') # size
self.detection_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'{\xc2\xf6\xcf') # 0x7bc2f6cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/|Y\xdc') # 0x2f7c59dc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_enabled))
data.write(b'k@\xac\xef') # 0x6b40acef
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.texture_set))
data.write(b'\xc7\xbd\x10"') # 0xc7bd1022
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behaviors.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
detection_box=Vector.from_json(data['detection_box']),
detection_offset=Vector.from_json(data['detection_offset']),
model=data['model'],
character=AnimationParameters.from_json(data['character']),
actor_information=ActorParameters.from_json(data['actor_information']),
start_enabled=data['start_enabled'],
texture_set=data['texture_set'],
behaviors=ReactiveActorBehaviors.from_json(data['behaviors']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'detection_box': self.detection_box.to_json(),
'detection_offset': self.detection_offset.to_json(),
'model': self.model,
'character': self.character.to_json(),
'actor_information': self.actor_information.to_json(),
'start_enabled': self.start_enabled,
'texture_set': self.texture_set,
'behaviors': self.behaviors.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_detection_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_detection_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_character(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_start_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_behaviors(data: typing.BinaryIO, property_size: int):
return ReactiveActorBehaviors.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6c447ff0: ('detection_box', _decode_detection_box),
0x3daf5302: ('detection_offset', _decode_detection_offset),
0xc27ffa8f: ('model', _decode_model),
0x7bc2f6cf: ('character', _decode_character),
0x7e397fed: ('actor_information', _decode_actor_information),
0x2f7c59dc: ('start_enabled', _decode_start_enabled),
0x6b40acef: ('texture_set', _decode_texture_set),
0xc7bd1022: ('behaviors', _decode_behaviors),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ReactiveActor.py | 0.654784 | 0.311231 | ReactiveActor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct18 import UnknownStruct18
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct276 import UnknownStruct276
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct32 import UnknownStruct32
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct33 import UnknownStruct33
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class TPND(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
tippy_platform_module: UnknownStruct33 = dataclasses.field(default_factory=UnknownStruct33)
motion_platform_module: UnknownStruct32 = dataclasses.field(default_factory=UnknownStruct32)
unknown_struct18: UnknownStruct18 = dataclasses.field(default_factory=UnknownStruct18)
unknown_struct276: UnknownStruct276 = dataclasses.field(default_factory=UnknownStruct276)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TPND'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf2\xd2\xc8\xe8') # 0xf2d2c8e8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tippy_platform_module.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x17K]\xc1') # 0x174b5dc1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_platform_module.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\xc6\xd9\xde') # 0xa1c6d9de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct18.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\r:\x1c\x85') # 0xd3a1c85
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct276.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
actor_information=ActorParameters.from_json(data['actor_information']),
model=data['model'],
collision_model=data['collision_model'],
animation=AnimationParameters.from_json(data['animation']),
tippy_platform_module=UnknownStruct33.from_json(data['tippy_platform_module']),
motion_platform_module=UnknownStruct32.from_json(data['motion_platform_module']),
unknown_struct18=UnknownStruct18.from_json(data['unknown_struct18']),
unknown_struct276=UnknownStruct276.from_json(data['unknown_struct276']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'actor_information': self.actor_information.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'animation': self.animation.to_json(),
'tippy_platform_module': self.tippy_platform_module.to_json(),
'motion_platform_module': self.motion_platform_module.to_json(),
'unknown_struct18': self.unknown_struct18.to_json(),
'unknown_struct276': self.unknown_struct276.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_tippy_platform_module(data: typing.BinaryIO, property_size: int):
return UnknownStruct33.from_stream(data, property_size)
def _decode_motion_platform_module(data: typing.BinaryIO, property_size: int):
return UnknownStruct32.from_stream(data, property_size)
def _decode_unknown_struct18(data: typing.BinaryIO, property_size: int):
return UnknownStruct18.from_stream(data, property_size)
def _decode_unknown_struct276(data: typing.BinaryIO, property_size: int):
return UnknownStruct276.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa3d63f44: ('animation', _decode_animation),
0xf2d2c8e8: ('tippy_platform_module', _decode_tippy_platform_module),
0x174b5dc1: ('motion_platform_module', _decode_motion_platform_module),
0xa1c6d9de: ('unknown_struct18', _decode_unknown_struct18),
0xd3a1c85: ('unknown_struct276', _decode_unknown_struct276),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TPND.py | 0.489748 | 0.280081 | TPND.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.KongProxyData import KongProxyData
@dataclasses.dataclass()
class KongProxy(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
kong_proxy_data: KongProxyData = dataclasses.field(default_factory=KongProxyData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'KNGP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\r\x8c\x9c') # 0x660d8c9c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.kong_proxy_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
kong_proxy_data=KongProxyData.from_json(data['kong_proxy_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'kong_proxy_data': self.kong_proxy_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_kong_proxy_data(data: typing.BinaryIO, property_size: int):
return KongProxyData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x660d8c9c: ('kong_proxy_data', _decode_kong_proxy_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/KongProxy.py | 0.621771 | 0.356279 | KongProxy.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.BarrelCannonData import BarrelCannonData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.dkc_returns.archetypes.PlatformMotionProperties import PlatformMotionProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct22 import UnknownStruct22
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 BarrelCannon(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
fsmc: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
maximum_splashes: int = dataclasses.field(default=200)
splash_generation_rate: int = dataclasses.field(default=20)
render_rain_splashes: bool = dataclasses.field(default=False)
unknown_0xf203bc81: bool = dataclasses.field(default=False)
motion_properties: PlatformMotionProperties = dataclasses.field(default_factory=PlatformMotionProperties)
unknown_0x24fdeea1: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.15000000596046448, z=0.0))
random_animation_offset: float = dataclasses.field(default=0.0)
unknown_0x6b5e87a7: float = dataclasses.field(default=1800.0)
look_at_velocity: float = dataclasses.field(default=30.0)
barrel_cannon_data: BarrelCannonData = dataclasses.field(default_factory=BarrelCannonData)
unknown_0xfaf13d08: bool = dataclasses.field(default=False)
unknown_struct22: UnknownStruct22 = dataclasses.field(default_factory=UnknownStruct22)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BARL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x15') # 21 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b!\xee\xb2') # 0x1b21eeb2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fsmc))
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
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'\xdc\xd5o\xe8') # 0xdcd56fe8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.maximum_splashes))
data.write(b'h-\xe1\\') # 0x682de15c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.splash_generation_rate))
data.write(b'\xac:\xdd\xa6') # 0xac3adda6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_rain_splashes))
data.write(b'\xf2\x03\xbc\x81') # 0xf203bc81
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf203bc81))
data.write(b'\n\x9d\xbf\x91') # 0xa9dbf91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xfd\xee\xa1') # 0x24fdeea1
data.write(b'\x00\x0c') # size
self.unknown_0x24fdeea1.to_stream(data)
data.write(b'\xbfi\xc0>') # 0xbf69c03e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_animation_offset))
data.write(b'k^\x87\xa7') # 0x6b5e87a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6b5e87a7))
data.write(b'=\xc7W3') # 0x3dc75733
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_at_velocity))
data.write(b'\xf0La\xf3') # 0xf04c61f3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.barrel_cannon_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa\xf1=\x08') # 0xfaf13d08
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xfaf13d08))
data.write(b'\xc9\xd2%\xc7') # 0xc9d225c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct22.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
model=data['model'],
animation=AnimationParameters.from_json(data['animation']),
fsmc=data['fsmc'],
actor_information=ActorParameters.from_json(data['actor_information']),
collision_model=data['collision_model'],
health=HealthInfo.from_json(data['health']),
maximum_splashes=data['maximum_splashes'],
splash_generation_rate=data['splash_generation_rate'],
render_rain_splashes=data['render_rain_splashes'],
unknown_0xf203bc81=data['unknown_0xf203bc81'],
motion_properties=PlatformMotionProperties.from_json(data['motion_properties']),
unknown_0x24fdeea1=Vector.from_json(data['unknown_0x24fdeea1']),
random_animation_offset=data['random_animation_offset'],
unknown_0x6b5e87a7=data['unknown_0x6b5e87a7'],
look_at_velocity=data['look_at_velocity'],
barrel_cannon_data=BarrelCannonData.from_json(data['barrel_cannon_data']),
unknown_0xfaf13d08=data['unknown_0xfaf13d08'],
unknown_struct22=UnknownStruct22.from_json(data['unknown_struct22']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'model': self.model,
'animation': self.animation.to_json(),
'fsmc': self.fsmc,
'actor_information': self.actor_information.to_json(),
'collision_model': self.collision_model,
'health': self.health.to_json(),
'maximum_splashes': self.maximum_splashes,
'splash_generation_rate': self.splash_generation_rate,
'render_rain_splashes': self.render_rain_splashes,
'unknown_0xf203bc81': self.unknown_0xf203bc81,
'motion_properties': self.motion_properties.to_json(),
'unknown_0x24fdeea1': self.unknown_0x24fdeea1.to_json(),
'random_animation_offset': self.random_animation_offset,
'unknown_0x6b5e87a7': self.unknown_0x6b5e87a7,
'look_at_velocity': self.look_at_velocity,
'barrel_cannon_data': self.barrel_cannon_data.to_json(),
'unknown_0xfaf13d08': self.unknown_0xfaf13d08,
'unknown_struct22': self.unknown_struct22.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_fsmc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_maximum_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_splash_generation_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_render_rain_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf203bc81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_properties(data: typing.BinaryIO, property_size: int):
return PlatformMotionProperties.from_stream(data, property_size)
def _decode_unknown_0x24fdeea1(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_random_animation_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6b5e87a7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_at_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_barrel_cannon_data(data: typing.BinaryIO, property_size: int):
return BarrelCannonData.from_stream(data, property_size)
def _decode_unknown_0xfaf13d08(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct22(data: typing.BinaryIO, property_size: int):
return UnknownStruct22.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xc27ffa8f: ('model', _decode_model),
0xa3d63f44: ('animation', _decode_animation),
0x1b21eeb2: ('fsmc', _decode_fsmc),
0x7e397fed: ('actor_information', _decode_actor_information),
0xfc966dc: ('collision_model', _decode_collision_model),
0xcf90d15e: ('health', _decode_health),
0xdcd56fe8: ('maximum_splashes', _decode_maximum_splashes),
0x682de15c: ('splash_generation_rate', _decode_splash_generation_rate),
0xac3adda6: ('render_rain_splashes', _decode_render_rain_splashes),
0xf203bc81: ('unknown_0xf203bc81', _decode_unknown_0xf203bc81),
0xa9dbf91: ('motion_properties', _decode_motion_properties),
0x24fdeea1: ('unknown_0x24fdeea1', _decode_unknown_0x24fdeea1),
0xbf69c03e: ('random_animation_offset', _decode_random_animation_offset),
0x6b5e87a7: ('unknown_0x6b5e87a7', _decode_unknown_0x6b5e87a7),
0x3dc75733: ('look_at_velocity', _decode_look_at_velocity),
0xf04c61f3: ('barrel_cannon_data', _decode_barrel_cannon_data),
0xfaf13d08: ('unknown_0xfaf13d08', _decode_unknown_0xfaf13d08),
0xc9d225c7: ('unknown_struct22', _decode_unknown_struct22),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BarrelCannon.py | 0.639849 | 0.254234 | BarrelCannon.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct510 import UnknownStruct510
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class ShadowProjector(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_scale: float = dataclasses.field(default=1.0)
shadow_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
shadow_height: float = dataclasses.field(default=100.0)
shadow_alpha: float = dataclasses.field(default=0.5)
shadow_fade_time: float = dataclasses.field(default=1.0)
unknown_0xbca8b742: bool = dataclasses.field(default=False)
render_in_foreground: bool = dataclasses.field(default=False)
unknown_0x606e341c: int = dataclasses.field(default=128)
unknown_struct510: UnknownStruct510 = dataclasses.field(default_factory=UnknownStruct510)
unknown_0x8ce1176e: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SHDW'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\x01\x1a9') # 0x1d011a39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_scale))
data.write(b'\xf3q\xedY') # 0xf371ed59
data.write(b'\x00\x0c') # size
self.shadow_offset.to_stream(data)
data.write(b'$\xec\x0f\xb0') # 0x24ec0fb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_height))
data.write(b'>,\xd3\x8d') # 0x3e2cd38d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_alpha))
data.write(b'\x8c\xcf6\xc0') # 0x8ccf36c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_fade_time))
data.write(b'\xbc\xa8\xb7B') # 0xbca8b742
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbca8b742))
data.write(b'\xa6\xaa\x06\xd5') # 0xa6aa06d5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_in_foreground))
data.write(b'`n4\x1c') # 0x606e341c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x606e341c))
data.write(b'\xa2\x1bQZ') # 0xa21b515a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct510.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c\xe1\x17n') # 0x8ce1176e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8ce1176e))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_scale=data['shadow_scale'],
shadow_offset=Vector.from_json(data['shadow_offset']),
shadow_height=data['shadow_height'],
shadow_alpha=data['shadow_alpha'],
shadow_fade_time=data['shadow_fade_time'],
unknown_0xbca8b742=data['unknown_0xbca8b742'],
render_in_foreground=data['render_in_foreground'],
unknown_0x606e341c=data['unknown_0x606e341c'],
unknown_struct510=UnknownStruct510.from_json(data['unknown_struct510']),
unknown_0x8ce1176e=data['unknown_0x8ce1176e'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_scale': self.shadow_scale,
'shadow_offset': self.shadow_offset.to_json(),
'shadow_height': self.shadow_height,
'shadow_alpha': self.shadow_alpha,
'shadow_fade_time': self.shadow_fade_time,
'unknown_0xbca8b742': self.unknown_0xbca8b742,
'render_in_foreground': self.render_in_foreground,
'unknown_0x606e341c': self.unknown_0x606e341c,
'unknown_struct510': self.unknown_struct510.to_json(),
'unknown_0x8ce1176e': self.unknown_0x8ce1176e,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_shadow_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbca8b742(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_in_foreground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x606e341c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct510(data: typing.BinaryIO, property_size: int):
return UnknownStruct510.from_stream(data, property_size)
def _decode_unknown_0x8ce1176e(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x1d011a39: ('shadow_scale', _decode_shadow_scale),
0xf371ed59: ('shadow_offset', _decode_shadow_offset),
0x24ec0fb0: ('shadow_height', _decode_shadow_height),
0x3e2cd38d: ('shadow_alpha', _decode_shadow_alpha),
0x8ccf36c0: ('shadow_fade_time', _decode_shadow_fade_time),
0xbca8b742: ('unknown_0xbca8b742', _decode_unknown_0xbca8b742),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
0x606e341c: ('unknown_0x606e341c', _decode_unknown_0x606e341c),
0xa21b515a: ('unknown_struct510', _decode_unknown_struct510),
0x8ce1176e: ('unknown_0x8ce1176e', _decode_unknown_0x8ce1176e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ShadowProjector.py | 0.609175 | 0.358157 | ShadowProjector.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.dkc_returns.archetypes.PlatformMotionProperties import PlatformMotionProperties
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct245 import UnknownStruct245
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 Platform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0xf203bc81: bool = dataclasses.field(default=False)
motion_properties: PlatformMotionProperties = dataclasses.field(default_factory=PlatformMotionProperties)
unknown_0x24fdeea1: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.15000000596046448, z=0.0))
random_animation_offset: float = dataclasses.field(default=0.0)
animation_time_scale: float = dataclasses.field(default=1.0)
unknown_0x6b5e87a7: float = dataclasses.field(default=1800.0)
look_at_velocity: float = dataclasses.field(default=30.0)
render_push: float = dataclasses.field(default=0.0)
unknown_0x981c2921: float = dataclasses.field(default=0.0)
unknown_0xb5b16553: bool = dataclasses.field(default=False)
unknown_0x58ee3422: bool = dataclasses.field(default=False)
unknown_0xbe04e10b: bool = dataclasses.field(default=False)
can_take_damage: bool = dataclasses.field(default=False)
unknown_0x47e9cc80: bool = dataclasses.field(default=False)
unknown_struct245: UnknownStruct245 = dataclasses.field(default_factory=UnknownStruct245)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PLAT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x19') # 25 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x81\xc8>') # 0xbf81c83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
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'{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'\xf2\x03\xbc\x81') # 0xf203bc81
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf203bc81))
data.write(b'\n\x9d\xbf\x91') # 0xa9dbf91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xfd\xee\xa1') # 0x24fdeea1
data.write(b'\x00\x0c') # size
self.unknown_0x24fdeea1.to_stream(data)
data.write(b'\xbfi\xc0>') # 0xbf69c03e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_animation_offset))
data.write(b'\xbeQ>+') # 0xbe513e2b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.animation_time_scale))
data.write(b'k^\x87\xa7') # 0x6b5e87a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6b5e87a7))
data.write(b'=\xc7W3') # 0x3dc75733
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_at_velocity))
data.write(b'\xaaq\x962') # 0xaa719632
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push))
data.write(b'\x98\x1c)!') # 0x981c2921
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x981c2921))
data.write(b'\xb5\xb1eS') # 0xb5b16553
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb5b16553))
data.write(b'X\xee4"') # 0x58ee3422
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x58ee3422))
data.write(b'\xbe\x04\xe1\x0b') # 0xbe04e10b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbe04e10b))
data.write(b'\x1f\xa9*\xc4') # 0x1fa92ac4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_take_damage))
data.write(b'G\xe9\xcc\x80') # 0x47e9cc80
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x47e9cc80))
data.write(b"\xa1\x17'D") # 0xa1172744
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct245.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
model=data['model'],
animation=AnimationParameters.from_json(data['animation']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
collision_model=data['collision_model'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
unknown_0xf203bc81=data['unknown_0xf203bc81'],
motion_properties=PlatformMotionProperties.from_json(data['motion_properties']),
unknown_0x24fdeea1=Vector.from_json(data['unknown_0x24fdeea1']),
random_animation_offset=data['random_animation_offset'],
animation_time_scale=data['animation_time_scale'],
unknown_0x6b5e87a7=data['unknown_0x6b5e87a7'],
look_at_velocity=data['look_at_velocity'],
render_push=data['render_push'],
unknown_0x981c2921=data['unknown_0x981c2921'],
unknown_0xb5b16553=data['unknown_0xb5b16553'],
unknown_0x58ee3422=data['unknown_0x58ee3422'],
unknown_0xbe04e10b=data['unknown_0xbe04e10b'],
can_take_damage=data['can_take_damage'],
unknown_0x47e9cc80=data['unknown_0x47e9cc80'],
unknown_struct245=UnknownStruct245.from_json(data['unknown_struct245']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'model': self.model,
'animation': self.animation.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'collision_model': self.collision_model,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'unknown_0xf203bc81': self.unknown_0xf203bc81,
'motion_properties': self.motion_properties.to_json(),
'unknown_0x24fdeea1': self.unknown_0x24fdeea1.to_json(),
'random_animation_offset': self.random_animation_offset,
'animation_time_scale': self.animation_time_scale,
'unknown_0x6b5e87a7': self.unknown_0x6b5e87a7,
'look_at_velocity': self.look_at_velocity,
'render_push': self.render_push,
'unknown_0x981c2921': self.unknown_0x981c2921,
'unknown_0xb5b16553': self.unknown_0xb5b16553,
'unknown_0x58ee3422': self.unknown_0x58ee3422,
'unknown_0xbe04e10b': self.unknown_0xbe04e10b,
'can_take_damage': self.can_take_damage,
'unknown_0x47e9cc80': self.unknown_0x47e9cc80,
'unknown_struct245': self.unknown_struct245.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_shadow_data(data: typing.BinaryIO, property_size: int):
return ShadowData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0xf203bc81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_properties(data: typing.BinaryIO, property_size: int):
return PlatformMotionProperties.from_stream(data, property_size)
def _decode_unknown_0x24fdeea1(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_random_animation_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation_time_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6b5e87a7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_at_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_render_push(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x981c2921(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb5b16553(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x58ee3422(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbe04e10b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_take_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x47e9cc80(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct245(data: typing.BinaryIO, property_size: int):
return UnknownStruct245.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xc27ffa8f: ('model', _decode_model),
0xa3d63f44: ('animation', _decode_animation),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0xfc966dc: ('collision_model', _decode_collision_model),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xf203bc81: ('unknown_0xf203bc81', _decode_unknown_0xf203bc81),
0xa9dbf91: ('motion_properties', _decode_motion_properties),
0x24fdeea1: ('unknown_0x24fdeea1', _decode_unknown_0x24fdeea1),
0xbf69c03e: ('random_animation_offset', _decode_random_animation_offset),
0xbe513e2b: ('animation_time_scale', _decode_animation_time_scale),
0x6b5e87a7: ('unknown_0x6b5e87a7', _decode_unknown_0x6b5e87a7),
0x3dc75733: ('look_at_velocity', _decode_look_at_velocity),
0xaa719632: ('render_push', _decode_render_push),
0x981c2921: ('unknown_0x981c2921', _decode_unknown_0x981c2921),
0xb5b16553: ('unknown_0xb5b16553', _decode_unknown_0xb5b16553),
0x58ee3422: ('unknown_0x58ee3422', _decode_unknown_0x58ee3422),
0xbe04e10b: ('unknown_0xbe04e10b', _decode_unknown_0xbe04e10b),
0x1fa92ac4: ('can_take_damage', _decode_can_take_damage),
0x47e9cc80: ('unknown_0x47e9cc80', _decode_unknown_0x47e9cc80),
0xa1172744: ('unknown_struct245', _decode_unknown_struct245),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Platform.py | 0.601594 | 0.25957 | Platform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.DebrisProperties import DebrisProperties
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Debris(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
debris_properties: DebrisProperties = dataclasses.field(default_factory=DebrisProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DEBR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8a\x1c\x82\x1d') # 0x8a1c821d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.debris_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
debris_properties=DebrisProperties.from_json(data['debris_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'debris_properties': self.debris_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_debris_properties(data: typing.BinaryIO, property_size: int):
return DebrisProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x8a1c821d: ('debris_properties', _decode_debris_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Debris.py | 0.662251 | 0.309487 | Debris.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0xc215a24f: int = dataclasses.field(default=0)
mirrored: bool = dataclasses.field(default=False)
force_secondary: bool = dataclasses.field(default=False)
loop: bool = dataclasses.field(default=False)
loop_duration: float = dataclasses.field(default=0.0)
unknown_0x6d62ef74: int = dataclasses.field(default=8)
playback_rate: float = dataclasses.field(default=1.0)
playback_blend_mode: enums.AnimEnum = dataclasses.field(default=enums.AnimEnum.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIKF'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\t') # 9 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x15\xa2O') # 0xc215a24f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc215a24f))
data.write(b'\x1f\xe4L:') # 0x1fe44c3a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.mirrored))
data.write(b'\\\xce[\x97') # 0x5cce5b97
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_secondary))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\xce\xe6\x87#') # 0xcee68723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.loop_duration))
data.write(b'mb\xeft') # 0x6d62ef74
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6d62ef74))
data.write(b'o\x8d4\xca') # 0x6f8d34ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.playback_rate))
data.write(b'\xed\x1f\x8a\xab') # 0xed1f8aab
data.write(b'\x00\x04') # size
self.playback_blend_mode.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_0xc215a24f=data['unknown_0xc215a24f'],
mirrored=data['mirrored'],
force_secondary=data['force_secondary'],
loop=data['loop'],
loop_duration=data['loop_duration'],
unknown_0x6d62ef74=data['unknown_0x6d62ef74'],
playback_rate=data['playback_rate'],
playback_blend_mode=enums.AnimEnum.from_json(data['playback_blend_mode']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0xc215a24f': self.unknown_0xc215a24f,
'mirrored': self.mirrored,
'force_secondary': self.force_secondary,
'loop': self.loop,
'loop_duration': self.loop_duration,
'unknown_0x6d62ef74': self.unknown_0x6d62ef74,
'playback_rate': self.playback_rate,
'playback_blend_mode': self.playback_blend_mode.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0xc215a24f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mirrored(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_force_secondary(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6d62ef74(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_playback_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_playback_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.AnimEnum.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc215a24f: ('unknown_0xc215a24f', _decode_unknown_0xc215a24f),
0x1fe44c3a: ('mirrored', _decode_mirrored),
0x5cce5b97: ('force_secondary', _decode_force_secondary),
0xeda47ff6: ('loop', _decode_loop),
0xcee68723: ('loop_duration', _decode_loop_duration),
0x6d62ef74: ('unknown_0x6d62ef74', _decode_unknown_0x6d62ef74),
0x6f8d34ca: ('playback_rate', _decode_playback_rate),
0xed1f8aab: ('playback_blend_mode', _decode_playback_blend_mode),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AIKeyframe.py | 0.597138 | 0.288607 | AIKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.AnimGridModifierData import AnimGridModifierData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ActorAnimGridModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
anim_grid: AnimGridModifierData = dataclasses.field(default_factory=AnimGridModifierData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AAGM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h\xfdI\xae') # 0x68fd49ae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.anim_grid.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
anim_grid=AnimGridModifierData.from_json(data['anim_grid']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'anim_grid': self.anim_grid.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_anim_grid(data: typing.BinaryIO, property_size: int):
return AnimGridModifierData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x68fd49ae: ('anim_grid', _decode_anim_grid),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ActorAnimGridModifier.py | 0.629091 | 0.34762 | ActorAnimGridModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.CameraShakerData import CameraShakerData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CameraShaker(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shaker_data: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CAMS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xadT\x7f\x96') # 0xad547f96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shaker_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shaker_data=CameraShakerData.from_json(data['shaker_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shaker_data': self.shaker_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shaker_data(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xad547f96: ('shaker_data', _decode_shaker_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CameraShaker.py | 0.666714 | 0.381565 | CameraShaker.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class GameOverDisplay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CSGO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GameOverDisplay.py | 0.600774 | 0.353177 | GameOverDisplay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TrainSequence(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TSEQ'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MoleTrain.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TrainSequence.py | 0.609989 | 0.374133 | TrainSequence.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct228 import UnknownStruct228
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct229 import UnknownStruct229
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 MoleCart(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
fsmc: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
cart_type: enums.CartType = dataclasses.field(default=enums.CartType.Unknown2)
unknown_struct228: UnknownStruct228 = dataclasses.field(default_factory=UnknownStruct228)
unknown_struct229: UnknownStruct229 = dataclasses.field(default_factory=UnknownStruct229)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MOLC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MoleTrain.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b!\xee\xb2') # 0x1b21eeb2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fsmc))
data.write(b'\xd0\xe8>a') # 0xd0e83e61
data.write(b'\x00\x04') # size
self.cart_type.to_stream(data)
data.write(b'\xb9\xfc\xde;') # 0xb9fcde3b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct228.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9B^K') # 0xc9425e4b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct229.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
actor_information=ActorParameters.from_json(data['actor_information']),
model=data['model'],
collision_model=data['collision_model'],
animation=AnimationParameters.from_json(data['animation']),
fsmc=data['fsmc'],
cart_type=enums.CartType.from_json(data['cart_type']),
unknown_struct228=UnknownStruct228.from_json(data['unknown_struct228']),
unknown_struct229=UnknownStruct229.from_json(data['unknown_struct229']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'actor_information': self.actor_information.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'animation': self.animation.to_json(),
'fsmc': self.fsmc,
'cart_type': self.cart_type.to_json(),
'unknown_struct228': self.unknown_struct228.to_json(),
'unknown_struct229': self.unknown_struct229.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_fsmc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cart_type(data: typing.BinaryIO, property_size: int):
return enums.CartType.from_stream(data)
def _decode_unknown_struct228(data: typing.BinaryIO, property_size: int):
return UnknownStruct228.from_stream(data, property_size)
def _decode_unknown_struct229(data: typing.BinaryIO, property_size: int):
return UnknownStruct229.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa3d63f44: ('animation', _decode_animation),
0x1b21eeb2: ('fsmc', _decode_fsmc),
0xd0e83e61: ('cart_type', _decode_cart_type),
0xb9fcde3b: ('unknown_struct228', _decode_unknown_struct228),
0xc9425e4b: ('unknown_struct229', _decode_unknown_struct229),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MoleCart.py | 0.557243 | 0.311296 | MoleCart.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.OptionalAreaAssetTypes import OptionalAreaAssetTypes
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class OptionalAreaAsset(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
optional_area_asset_types: OptionalAreaAssetTypes = dataclasses.field(default_factory=OptionalAreaAssetTypes)
asset: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'OPAA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xf4Jh') # 0xff44a68
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.optional_area_asset_types.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0bL\x13\xa0') # 0xb4c13a0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.asset))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
optional_area_asset_types=OptionalAreaAssetTypes.from_json(data['optional_area_asset_types']),
asset=data['asset'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'optional_area_asset_types': self.optional_area_asset_types.to_json(),
'asset': self.asset,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_optional_area_asset_types(data: typing.BinaryIO, property_size: int):
return OptionalAreaAssetTypes.from_stream(data, property_size)
def _decode_asset(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xff44a68: ('optional_area_asset_types', _decode_optional_area_asset_types),
0xb4c13a0: ('asset', _decode_asset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/OptionalAreaAsset.py | 0.703957 | 0.30063 | OptionalAreaAsset.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class FalsePerspective(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
percentage_of_depth_range: float = dataclasses.field(default=0.0010000000474974513)
near_clip_plane: float = dataclasses.field(default=20.0)
far_clip_plane: float = dataclasses.field(default=8192.0)
unknown: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FLPS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7fpe\xd3') # 0x7f7065d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.percentage_of_depth_range))
data.write(b'\xf4\x81\x7f\x13') # 0xf4817f13
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.near_clip_plane))
data.write(b'\x84\xecJt') # 0x84ec4a74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_clip_plane))
data.write(b'\xa9\xd5\xffH') # 0xa9d5ff48
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
percentage_of_depth_range=data['percentage_of_depth_range'],
near_clip_plane=data['near_clip_plane'],
far_clip_plane=data['far_clip_plane'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'percentage_of_depth_range': self.percentage_of_depth_range,
'near_clip_plane': self.near_clip_plane,
'far_clip_plane': self.far_clip_plane,
'unknown': self.unknown,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_percentage_of_depth_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_near_clip_plane(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_clip_plane(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7f7065d3: ('percentage_of_depth_range', _decode_percentage_of_depth_range),
0xf4817f13: ('near_clip_plane', _decode_near_clip_plane),
0x84ec4a74: ('far_clip_plane', _decode_far_clip_plane),
0xa9d5ff48: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/FalsePerspective.py | 0.666931 | 0.382862 | FalsePerspective.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class GuiCharacter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
widget_name: str = dataclasses.field(default='')
unknown_0x8b891f5a: str = dataclasses.field(default='')
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x181e33cc: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
idle_animation: int = dataclasses.field(default=0)
unknown_0xc23bd607: int = dataclasses.field(default=0)
unknown_0x4a6a84c1: int = dataclasses.field(default=0)
unknown_0x601fce68: int = dataclasses.field(default=0)
unknown_0x63e53fd8: int = dataclasses.field(default=0)
unknown_0x247db024: int = dataclasses.field(default=0)
unknown_0xfdccb479: int = dataclasses.field(default=0)
unknown_0x10706107: int = dataclasses.field(default=0)
unknown_0x98e160f8: int = dataclasses.field(default=0)
unknown_0x3bb7e651: int = dataclasses.field(default=0)
unknown_0xec556609: int = dataclasses.field(default=0)
unknown_0xa66bed42: int = dataclasses.field(default=0)
unknown_0x71896d1a: int = dataclasses.field(default=0)
unknown_0xd2dfebb3: int = dataclasses.field(default=0)
unknown_0x053d6beb: int = dataclasses.field(default=0)
unknown_0x46a2fd25: int = dataclasses.field(default=0)
unknown_0x91407d7d: int = dataclasses.field(default=0)
unknown_0x579ed88f: int = dataclasses.field(default=0)
unknown_0x807c58d7: int = dataclasses.field(default=0)
unknown_0x232ade7e: int = dataclasses.field(default=0)
unknown_0xf4c85e26: int = dataclasses.field(default=0)
unknown_0xbef6d56d: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GUCH'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1c') # 28 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|$W\xbc') # 0x7c2457bc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.widget_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'\x8b\x89\x1fZ') # 0x8b891f5a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x8b891f5a.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'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\x18\x1e3\xcc') # 0x181e33cc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x181e33cc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2\xa5\xb3\x8f') # 0xa2a5b38f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.idle_animation))
data.write(b'\xc2;\xd6\x07') # 0xc23bd607
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc23bd607))
data.write(b'Jj\x84\xc1') # 0x4a6a84c1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x4a6a84c1))
data.write(b'`\x1f\xceh') # 0x601fce68
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x601fce68))
data.write(b'c\xe5?\xd8') # 0x63e53fd8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x63e53fd8))
data.write(b'$}\xb0$') # 0x247db024
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x247db024))
data.write(b'\xfd\xcc\xb4y') # 0xfdccb479
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xfdccb479))
data.write(b'\x10pa\x07') # 0x10706107
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x10706107))
data.write(b'\x98\xe1`\xf8') # 0x98e160f8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x98e160f8))
data.write(b';\xb7\xe6Q') # 0x3bb7e651
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3bb7e651))
data.write(b'\xecUf\t') # 0xec556609
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xec556609))
data.write(b'\xa6k\xedB') # 0xa66bed42
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xa66bed42))
data.write(b'q\x89m\x1a') # 0x71896d1a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x71896d1a))
data.write(b'\xd2\xdf\xeb\xb3') # 0xd2dfebb3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd2dfebb3))
data.write(b'\x05=k\xeb') # 0x53d6beb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x053d6beb))
data.write(b'F\xa2\xfd%') # 0x46a2fd25
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x46a2fd25))
data.write(b'\x91@}}') # 0x91407d7d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x91407d7d))
data.write(b'W\x9e\xd8\x8f') # 0x579ed88f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x579ed88f))
data.write(b'\x80|X\xd7') # 0x807c58d7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x807c58d7))
data.write(b'#*\xde~') # 0x232ade7e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x232ade7e))
data.write(b'\xf4\xc8^&') # 0xf4c85e26
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xf4c85e26))
data.write(b'\xbe\xf6\xd5m') # 0xbef6d56d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xbef6d56d))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
widget_name=data['widget_name'],
unknown_0x8b891f5a=data['unknown_0x8b891f5a'],
actor_information=ActorParameters.from_json(data['actor_information']),
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
unknown_0x181e33cc=AnimationParameters.from_json(data['unknown_0x181e33cc']),
idle_animation=data['idle_animation'],
unknown_0xc23bd607=data['unknown_0xc23bd607'],
unknown_0x4a6a84c1=data['unknown_0x4a6a84c1'],
unknown_0x601fce68=data['unknown_0x601fce68'],
unknown_0x63e53fd8=data['unknown_0x63e53fd8'],
unknown_0x247db024=data['unknown_0x247db024'],
unknown_0xfdccb479=data['unknown_0xfdccb479'],
unknown_0x10706107=data['unknown_0x10706107'],
unknown_0x98e160f8=data['unknown_0x98e160f8'],
unknown_0x3bb7e651=data['unknown_0x3bb7e651'],
unknown_0xec556609=data['unknown_0xec556609'],
unknown_0xa66bed42=data['unknown_0xa66bed42'],
unknown_0x71896d1a=data['unknown_0x71896d1a'],
unknown_0xd2dfebb3=data['unknown_0xd2dfebb3'],
unknown_0x053d6beb=data['unknown_0x053d6beb'],
unknown_0x46a2fd25=data['unknown_0x46a2fd25'],
unknown_0x91407d7d=data['unknown_0x91407d7d'],
unknown_0x579ed88f=data['unknown_0x579ed88f'],
unknown_0x807c58d7=data['unknown_0x807c58d7'],
unknown_0x232ade7e=data['unknown_0x232ade7e'],
unknown_0xf4c85e26=data['unknown_0xf4c85e26'],
unknown_0xbef6d56d=data['unknown_0xbef6d56d'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'widget_name': self.widget_name,
'unknown_0x8b891f5a': self.unknown_0x8b891f5a,
'actor_information': self.actor_information.to_json(),
'character_animation_information': self.character_animation_information.to_json(),
'unknown_0x181e33cc': self.unknown_0x181e33cc.to_json(),
'idle_animation': self.idle_animation,
'unknown_0xc23bd607': self.unknown_0xc23bd607,
'unknown_0x4a6a84c1': self.unknown_0x4a6a84c1,
'unknown_0x601fce68': self.unknown_0x601fce68,
'unknown_0x63e53fd8': self.unknown_0x63e53fd8,
'unknown_0x247db024': self.unknown_0x247db024,
'unknown_0xfdccb479': self.unknown_0xfdccb479,
'unknown_0x10706107': self.unknown_0x10706107,
'unknown_0x98e160f8': self.unknown_0x98e160f8,
'unknown_0x3bb7e651': self.unknown_0x3bb7e651,
'unknown_0xec556609': self.unknown_0xec556609,
'unknown_0xa66bed42': self.unknown_0xa66bed42,
'unknown_0x71896d1a': self.unknown_0x71896d1a,
'unknown_0xd2dfebb3': self.unknown_0xd2dfebb3,
'unknown_0x053d6beb': self.unknown_0x053d6beb,
'unknown_0x46a2fd25': self.unknown_0x46a2fd25,
'unknown_0x91407d7d': self.unknown_0x91407d7d,
'unknown_0x579ed88f': self.unknown_0x579ed88f,
'unknown_0x807c58d7': self.unknown_0x807c58d7,
'unknown_0x232ade7e': self.unknown_0x232ade7e,
'unknown_0xf4c85e26': self.unknown_0xf4c85e26,
'unknown_0xbef6d56d': self.unknown_0xbef6d56d,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_widget_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x8b891f5a(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x181e33cc(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_idle_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc23bd607(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x4a6a84c1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x601fce68(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x63e53fd8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x247db024(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xfdccb479(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x10706107(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x98e160f8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x3bb7e651(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xec556609(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xa66bed42(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x71896d1a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd2dfebb3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x053d6beb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x46a2fd25(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x91407d7d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x579ed88f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x807c58d7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x232ade7e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xf4c85e26(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xbef6d56d(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7c2457bc: ('widget_name', _decode_widget_name),
0x8b891f5a: ('unknown_0x8b891f5a', _decode_unknown_0x8b891f5a),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x181e33cc: ('unknown_0x181e33cc', _decode_unknown_0x181e33cc),
0xa2a5b38f: ('idle_animation', _decode_idle_animation),
0xc23bd607: ('unknown_0xc23bd607', _decode_unknown_0xc23bd607),
0x4a6a84c1: ('unknown_0x4a6a84c1', _decode_unknown_0x4a6a84c1),
0x601fce68: ('unknown_0x601fce68', _decode_unknown_0x601fce68),
0x63e53fd8: ('unknown_0x63e53fd8', _decode_unknown_0x63e53fd8),
0x247db024: ('unknown_0x247db024', _decode_unknown_0x247db024),
0xfdccb479: ('unknown_0xfdccb479', _decode_unknown_0xfdccb479),
0x10706107: ('unknown_0x10706107', _decode_unknown_0x10706107),
0x98e160f8: ('unknown_0x98e160f8', _decode_unknown_0x98e160f8),
0x3bb7e651: ('unknown_0x3bb7e651', _decode_unknown_0x3bb7e651),
0xec556609: ('unknown_0xec556609', _decode_unknown_0xec556609),
0xa66bed42: ('unknown_0xa66bed42', _decode_unknown_0xa66bed42),
0x71896d1a: ('unknown_0x71896d1a', _decode_unknown_0x71896d1a),
0xd2dfebb3: ('unknown_0xd2dfebb3', _decode_unknown_0xd2dfebb3),
0x53d6beb: ('unknown_0x053d6beb', _decode_unknown_0x053d6beb),
0x46a2fd25: ('unknown_0x46a2fd25', _decode_unknown_0x46a2fd25),
0x91407d7d: ('unknown_0x91407d7d', _decode_unknown_0x91407d7d),
0x579ed88f: ('unknown_0x579ed88f', _decode_unknown_0x579ed88f),
0x807c58d7: ('unknown_0x807c58d7', _decode_unknown_0x807c58d7),
0x232ade7e: ('unknown_0x232ade7e', _decode_unknown_0x232ade7e),
0xf4c85e26: ('unknown_0xf4c85e26', _decode_unknown_0xf4c85e26),
0xbef6d56d: ('unknown_0xbef6d56d', _decode_unknown_0xbef6d56d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GuiCharacter.py | 0.559531 | 0.227362 | GuiCharacter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct24 import UnknownStruct24
@dataclasses.dataclass()
class ScriptLayerController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
layer_list: UnknownStruct24 = dataclasses.field(default_factory=UnknownStruct24)
is_dynamic: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SLCT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Ak\xd9\xeb') # 0x416bd9eb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_list.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\xa7\xd8\xb2') # 0x12a7d8b2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_dynamic))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
layer_list=UnknownStruct24.from_json(data['layer_list']),
is_dynamic=data['is_dynamic'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'layer_list': self.layer_list.to_json(),
'is_dynamic': self.is_dynamic,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_layer_list(data: typing.BinaryIO, property_size: int):
return UnknownStruct24.from_stream(data, property_size)
def _decode_is_dynamic(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x416bd9eb: ('layer_list', _decode_layer_list),
0x12a7d8b2: ('is_dynamic', _decode_is_dynamic),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ScriptLayerController.py | 0.616012 | 0.344278 | ScriptLayerController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class VolumeGroup(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
group_name: str = dataclasses.field(default='')
volume: float = dataclasses.field(default=1.0)
inverted: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'VOLG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'o\xe83=') # 0x6fe8333d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.group_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'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'p\xfd\xfc\xc4') # 0x70fdfcc4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.inverted))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
group_name=data['group_name'],
volume=data['volume'],
inverted=data['inverted'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'group_name': self.group_name,
'volume': self.volume,
'inverted': self.inverted,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_group_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_inverted(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6fe8333d: ('group_name', _decode_group_name),
0xc7a7f189: ('volume', _decode_volume),
0x70fdfcc4: ('inverted', _decode_inverted),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/VolumeGroup.py | 0.635336 | 0.359196 | VolumeGroup.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PeanutProperties import PeanutProperties
@dataclasses.dataclass()
class Peanut(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
peanut_properties: PeanutProperties = dataclasses.field(default_factory=PeanutProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PNUT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'_\x05\x8fg') # 0x5f058f67
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.peanut_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
peanut_properties=PeanutProperties.from_json(data['peanut_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'peanut_properties': self.peanut_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_peanut_properties(data: typing.BinaryIO, property_size: int):
return PeanutProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x5f058f67: ('peanut_properties', _decode_peanut_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Peanut.py | 0.680242 | 0.315103 | Peanut.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.KongData import KongData
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.PlayerAlternateSkin import PlayerAlternateSkin
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct import UnknownStruct
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct227 import UnknownStruct227
@dataclasses.dataclass()
class Kong(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct: UnknownStruct = dataclasses.field(default_factory=UnknownStruct)
patterned_info: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
alternate_skins: PlayerAlternateSkin = dataclasses.field(default_factory=PlayerAlternateSkin)
kong_data: KongData = dataclasses.field(default_factory=KongData)
unknown_struct227: UnknownStruct227 = dataclasses.field(default_factory=UnknownStruct227)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'KONG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x81\xc8>') # 0xbf81c83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00c\xf68') # 0x63f638
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\xbb\xb1\xdd') # 0x43bbb1dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_info.to_stream(data, default_override={'step_up_height': 0.25})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b".\x98'\xad") # 0x2e9827ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.alternate_skins.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'ot8\xcf') # 0x6f7438cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.kong_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9c~\x90Q') # 0x9c7e9051
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct227.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct=UnknownStruct.from_json(data['unknown_struct']),
patterned_info=PatternedAITypedef.from_json(data['patterned_info']),
alternate_skins=PlayerAlternateSkin.from_json(data['alternate_skins']),
kong_data=KongData.from_json(data['kong_data']),
unknown_struct227=UnknownStruct227.from_json(data['unknown_struct227']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct': self.unknown_struct.to_json(),
'patterned_info': self.patterned_info.to_json(),
'alternate_skins': self.alternate_skins.to_json(),
'kong_data': self.kong_data.to_json(),
'unknown_struct227': self.unknown_struct227.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_data(data: typing.BinaryIO, property_size: int):
return ShadowData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct(data: typing.BinaryIO, property_size: int):
return UnknownStruct.from_stream(data, property_size)
def _decode_patterned_info(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'step_up_height': 0.25})
def _decode_alternate_skins(data: typing.BinaryIO, property_size: int):
return PlayerAlternateSkin.from_stream(data, property_size)
def _decode_kong_data(data: typing.BinaryIO, property_size: int):
return KongData.from_stream(data, property_size)
def _decode_unknown_struct227(data: typing.BinaryIO, property_size: int):
return UnknownStruct227.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0x63f638: ('unknown_struct', _decode_unknown_struct),
0x43bbb1dd: ('patterned_info', _decode_patterned_info),
0x2e9827ad: ('alternate_skins', _decode_alternate_skins),
0x6f7438cf: ('kong_data', _decode_kong_data),
0x9c7e9051: ('unknown_struct227', _decode_unknown_struct227),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Kong.py | 0.571288 | 0.334182 | Kong.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SoundModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
global_: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SNDM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\t\xb9\x06') # 0x2409b906
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.global_))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
global_=data['global_'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'global_': self.global_,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_global_(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x2409b906: ('global_', _decode_global_),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SoundModifier.py | 0.632049 | 0.356251 | SoundModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AudioOccluder(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
volume_attenuation: float = dataclasses.field(default=1.0)
unknown: int = dataclasses.field(default=32000)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AOCL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe\x89\xb6\xe4') # 0xfe89b6e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_attenuation))
data.write(b'\xfa{VP') # 0xfa7b5650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
volume_attenuation=data['volume_attenuation'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'volume_attenuation': self.volume_attenuation,
'unknown': self.unknown,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_volume_attenuation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfe89b6e4: ('volume_attenuation', _decode_volume_attenuation),
0xfa7b5650: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AudioOccluder.py | 0.66769 | 0.358325 | AudioOccluder.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class Generator(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
min_number_objects_to_generate: int = dataclasses.field(default=1)
max_number_objects_to_generate: int = dataclasses.field(default=1)
send_activate_message: bool = dataclasses.field(default=True)
unique_objects: bool = dataclasses.field(default=False)
unique_locations: bool = dataclasses.field(default=False)
keep_orientation: bool = dataclasses.field(default=False)
use_originator_transform: bool = dataclasses.field(default=False)
generate_in_sets_when_deleter_present: bool = dataclasses.field(default=True)
prioritize_clrm: bool = dataclasses.field(default=True)
offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
offset_is_local_space: bool = dataclasses.field(default=False)
random_scale_min: float = dataclasses.field(default=1.0)
random_scale_max: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GENR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k\xddV\xd6') # 0x6bdd56d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.min_number_objects_to_generate))
data.write(b'\x84_H\xac') # 0x845f48ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_number_objects_to_generate))
data.write(b'`x\xa1\xf0') # 0x6078a1f0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.send_activate_message))
data.write(b'\xe4\xd2G\xe4') # 0xe4d247e4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unique_objects))
data.write(b'\x88\x97\x8eI') # 0x88978e49
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unique_locations))
data.write(b'\x1e\xb8\xe2T') # 0x1eb8e254
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.keep_orientation))
data.write(b'\x03Z^\x10') # 0x35a5e10
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_originator_transform))
data.write(b'\xfa\xda\x16;') # 0xfada163b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.generate_in_sets_when_deleter_present))
data.write(b'\xe4\\wv') # 0xe45c7776
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.prioritize_clrm))
data.write(b'FGpd') # 0x46477064
data.write(b'\x00\x0c') # size
self.offset.to_stream(data)
data.write(b'r\xbb\xe7\xa6') # 0x72bbe7a6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.offset_is_local_space))
data.write(b'\xc3\x86\x1bd') # 0xc3861b64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_scale_min))
data.write(b'%\xe6\xb4\x85') # 0x25e6b485
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_scale_max))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
min_number_objects_to_generate=data['min_number_objects_to_generate'],
max_number_objects_to_generate=data['max_number_objects_to_generate'],
send_activate_message=data['send_activate_message'],
unique_objects=data['unique_objects'],
unique_locations=data['unique_locations'],
keep_orientation=data['keep_orientation'],
use_originator_transform=data['use_originator_transform'],
generate_in_sets_when_deleter_present=data['generate_in_sets_when_deleter_present'],
prioritize_clrm=data['prioritize_clrm'],
offset=Vector.from_json(data['offset']),
offset_is_local_space=data['offset_is_local_space'],
random_scale_min=data['random_scale_min'],
random_scale_max=data['random_scale_max'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'min_number_objects_to_generate': self.min_number_objects_to_generate,
'max_number_objects_to_generate': self.max_number_objects_to_generate,
'send_activate_message': self.send_activate_message,
'unique_objects': self.unique_objects,
'unique_locations': self.unique_locations,
'keep_orientation': self.keep_orientation,
'use_originator_transform': self.use_originator_transform,
'generate_in_sets_when_deleter_present': self.generate_in_sets_when_deleter_present,
'prioritize_clrm': self.prioritize_clrm,
'offset': self.offset.to_json(),
'offset_is_local_space': self.offset_is_local_space,
'random_scale_min': self.random_scale_min,
'random_scale_max': self.random_scale_max,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_min_number_objects_to_generate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_number_objects_to_generate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_send_activate_message(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unique_objects(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unique_locations(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_keep_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_originator_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_generate_in_sets_when_deleter_present(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_prioritize_clrm(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_offset_is_local_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_random_scale_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_scale_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6bdd56d6: ('min_number_objects_to_generate', _decode_min_number_objects_to_generate),
0x845f48ac: ('max_number_objects_to_generate', _decode_max_number_objects_to_generate),
0x6078a1f0: ('send_activate_message', _decode_send_activate_message),
0xe4d247e4: ('unique_objects', _decode_unique_objects),
0x88978e49: ('unique_locations', _decode_unique_locations),
0x1eb8e254: ('keep_orientation', _decode_keep_orientation),
0x35a5e10: ('use_originator_transform', _decode_use_originator_transform),
0xfada163b: ('generate_in_sets_when_deleter_present', _decode_generate_in_sets_when_deleter_present),
0xe45c7776: ('prioritize_clrm', _decode_prioritize_clrm),
0x46477064: ('offset', _decode_offset),
0x72bbe7a6: ('offset_is_local_space', _decode_offset_is_local_space),
0xc3861b64: ('random_scale_min', _decode_random_scale_min),
0x25e6b485: ('random_scale_max', _decode_random_scale_max),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Generator.py | 0.59749 | 0.384334 | Generator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.BalloonData import BalloonData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RespawnBalloon(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
balloon_data: BalloonData = dataclasses.field(default_factory=BalloonData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RSBL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\n\xa1\xaa\xe7') # 0xaa1aae7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.balloon_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
balloon_data=BalloonData.from_json(data['balloon_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'balloon_data': self.balloon_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_balloon_data(data: typing.BinaryIO, property_size: int):
return BalloonData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xaa1aae7: ('balloon_data', _decode_balloon_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RespawnBalloon.py | 0.699973 | 0.325628 | RespawnBalloon.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AreaStreamedAudioState(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
area_state: enums.MusicEnumB = dataclasses.field(default=enums.MusicEnumB.Unknown1)
auto_set: bool = dataclasses.field(default=False)
global_: bool = dataclasses.field(default=False)
unknown_0xeb9f334c: bool = dataclasses.field(default=False)
increment_delay: float = dataclasses.field(default=0.0)
decrement_delay: float = dataclasses.field(default=0.0)
unknown_0xcab4886b: bool = dataclasses.field(default=False)
custom_increment_fade_in: float = dataclasses.field(default=0.0)
custom_increment_fade_out: float = dataclasses.field(default=0.0)
unknown_0x8c95539a: bool = dataclasses.field(default=False)
custom_decrement_fade_in: float = dataclasses.field(default=0.0)
custom_decrement_fade_out: float = dataclasses.field(default=0.0)
unknown_0x250142a2: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ASAS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\xd8\xd8#') # 0xe7d8d823
data.write(b'\x00\x04') # size
self.area_state.to_stream(data)
data.write(b'\x05\xc9$l') # 0x5c9246c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_set))
data.write(b'$\t\xb9\x06') # 0x2409b906
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.global_))
data.write(b'\xeb\x9f3L') # 0xeb9f334c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xeb9f334c))
data.write(b'\xee\xb3\x90i') # 0xeeb39069
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.increment_delay))
data.write(b'$Os8') # 0x244f7338
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.decrement_delay))
data.write(b'\xca\xb4\x88k') # 0xcab4886b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcab4886b))
data.write(b'\x1b\xb8\x197') # 0x1bb81937
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.custom_increment_fade_in))
data.write(b'gH\xb6A') # 0x6748b641
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.custom_increment_fade_out))
data.write(b'\x8c\x95S\x9a') # 0x8c95539a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8c95539a))
data.write(b'\x07\x1e\x84\xb6') # 0x71e84b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.custom_decrement_fade_in))
data.write(b'\xfd\xeb\xa3j') # 0xfdeba36a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.custom_decrement_fade_out))
data.write(b'%\x01B\xa2') # 0x250142a2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x250142a2))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
area_state=enums.MusicEnumB.from_json(data['area_state']),
auto_set=data['auto_set'],
global_=data['global_'],
unknown_0xeb9f334c=data['unknown_0xeb9f334c'],
increment_delay=data['increment_delay'],
decrement_delay=data['decrement_delay'],
unknown_0xcab4886b=data['unknown_0xcab4886b'],
custom_increment_fade_in=data['custom_increment_fade_in'],
custom_increment_fade_out=data['custom_increment_fade_out'],
unknown_0x8c95539a=data['unknown_0x8c95539a'],
custom_decrement_fade_in=data['custom_decrement_fade_in'],
custom_decrement_fade_out=data['custom_decrement_fade_out'],
unknown_0x250142a2=data['unknown_0x250142a2'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'area_state': self.area_state.to_json(),
'auto_set': self.auto_set,
'global_': self.global_,
'unknown_0xeb9f334c': self.unknown_0xeb9f334c,
'increment_delay': self.increment_delay,
'decrement_delay': self.decrement_delay,
'unknown_0xcab4886b': self.unknown_0xcab4886b,
'custom_increment_fade_in': self.custom_increment_fade_in,
'custom_increment_fade_out': self.custom_increment_fade_out,
'unknown_0x8c95539a': self.unknown_0x8c95539a,
'custom_decrement_fade_in': self.custom_decrement_fade_in,
'custom_decrement_fade_out': self.custom_decrement_fade_out,
'unknown_0x250142a2': self.unknown_0x250142a2,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_area_state(data: typing.BinaryIO, property_size: int):
return enums.MusicEnumB.from_stream(data)
def _decode_auto_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_global_(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xeb9f334c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_increment_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_decrement_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcab4886b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_custom_increment_fade_in(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_custom_increment_fade_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8c95539a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_custom_decrement_fade_in(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_custom_decrement_fade_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x250142a2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe7d8d823: ('area_state', _decode_area_state),
0x5c9246c: ('auto_set', _decode_auto_set),
0x2409b906: ('global_', _decode_global_),
0xeb9f334c: ('unknown_0xeb9f334c', _decode_unknown_0xeb9f334c),
0xeeb39069: ('increment_delay', _decode_increment_delay),
0x244f7338: ('decrement_delay', _decode_decrement_delay),
0xcab4886b: ('unknown_0xcab4886b', _decode_unknown_0xcab4886b),
0x1bb81937: ('custom_increment_fade_in', _decode_custom_increment_fade_in),
0x6748b641: ('custom_increment_fade_out', _decode_custom_increment_fade_out),
0x8c95539a: ('unknown_0x8c95539a', _decode_unknown_0x8c95539a),
0x71e84b6: ('custom_decrement_fade_in', _decode_custom_decrement_fade_in),
0xfdeba36a: ('custom_decrement_fade_out', _decode_custom_decrement_fade_out),
0x250142a2: ('unknown_0x250142a2', _decode_unknown_0x250142a2),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AreaStreamedAudioState.py | 0.576065 | 0.310629 | AreaStreamedAudioState.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ConditionalTest import ConditionalTest
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ConditionalRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger_on_first_think: bool = dataclasses.field(default=False)
conditional1: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional2: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional3: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional4: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D\xdb\x8a\xf2') # 0x44db8af2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.trigger_on_first_think))
data.write(b'\xce\xc1i2') # 0xcec16932
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\t\xdd\xc0') # 0xe709ddc0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional2.to_stream(data, default_override={'boolean': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'IaLQ') # 0x49614c51
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional3.to_stream(data, default_override={'boolean': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\x98\xb4$') # 0xb498b424
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional4.to_stream(data, default_override={'boolean': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
trigger_on_first_think=data['trigger_on_first_think'],
conditional1=ConditionalTest.from_json(data['conditional1']),
conditional2=ConditionalTest.from_json(data['conditional2']),
conditional3=ConditionalTest.from_json(data['conditional3']),
conditional4=ConditionalTest.from_json(data['conditional4']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger_on_first_think': self.trigger_on_first_think,
'conditional1': self.conditional1.to_json(),
'conditional2': self.conditional2.to_json(),
'conditional3': self.conditional3.to_json(),
'conditional4': self.conditional4.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger_on_first_think(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_conditional1(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size)
def _decode_conditional2(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': 0})
def _decode_conditional3(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': 0})
def _decode_conditional4(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': 0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44db8af2: ('trigger_on_first_think', _decode_trigger_on_first_think),
0xcec16932: ('conditional1', _decode_conditional1),
0xe709ddc0: ('conditional2', _decode_conditional2),
0x49614c51: ('conditional3', _decode_conditional3),
0xb498b424: ('conditional4', _decode_conditional4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ConditionalRelay.py | 0.656548 | 0.323674 | ConditionalRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Color import Color
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class FogOverlay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
full_alpha: float = dataclasses.field(default=1.0)
fade_down_time: float = dataclasses.field(default=1.0)
fade_up_time: float = dataclasses.field(default=1.0)
start_faded_out: bool = dataclasses.field(default=False)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
ambient_radius_x: float = dataclasses.field(default=0.5)
ambient_radius_y: float = dataclasses.field(default=0.20000000298023224)
ambient_speed: float = dataclasses.field(default=0.10000000149011612)
ambient_speed_target: float = dataclasses.field(default=0.10000000149011612)
unknown_0x6a111b96: float = dataclasses.field(default=1.0)
unknown_0xff226ea3: float = dataclasses.field(default=1.0)
unknown_0x2190ab0a: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x9f19f0af: float = dataclasses.field(default=0.10000000149011612)
unknown_0x90c10fe7: float = dataclasses.field(default=1.0)
unknown_0xd8daff1d: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOGO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x10') # 16 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'T{(\xd5') # 0x547b28d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_alpha))
data.write(b'\xf9w\xcb5') # 0xf977cb35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_down_time))
data.write(b'\r!\xd3H') # 0xd21d348
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_up_time))
data.write(b'\xeb%\n\x0b') # 0xeb250a0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_faded_out))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\x1b\x90F\xd6') # 0x1b9046d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_radius_x))
data.write(b'\xd0\xcc\x95s') # 0xd0cc9573
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_radius_y))
data.write(b'\xf7k\xcb\xdd') # 0xf76bcbdd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_speed))
data.write(b',Lg\x85') # 0x2c4c6785
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_speed_target))
data.write(b'j\x11\x1b\x96') # 0x6a111b96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6a111b96))
data.write(b'\xff"n\xa3') # 0xff226ea3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xff226ea3))
data.write(b'!\x90\xab\n') # 0x2190ab0a
data.write(b'\x00\x0c') # size
self.unknown_0x2190ab0a.to_stream(data)
data.write(b'\x9f\x19\xf0\xaf') # 0x9f19f0af
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9f19f0af))
data.write(b'\x90\xc1\x0f\xe7') # 0x90c10fe7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x90c10fe7))
data.write(b'\xd8\xda\xff\x1d') # 0xd8daff1d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd8daff1d))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
full_alpha=data['full_alpha'],
fade_down_time=data['fade_down_time'],
fade_up_time=data['fade_up_time'],
start_faded_out=data['start_faded_out'],
color=Color.from_json(data['color']),
ambient_radius_x=data['ambient_radius_x'],
ambient_radius_y=data['ambient_radius_y'],
ambient_speed=data['ambient_speed'],
ambient_speed_target=data['ambient_speed_target'],
unknown_0x6a111b96=data['unknown_0x6a111b96'],
unknown_0xff226ea3=data['unknown_0xff226ea3'],
unknown_0x2190ab0a=Vector.from_json(data['unknown_0x2190ab0a']),
unknown_0x9f19f0af=data['unknown_0x9f19f0af'],
unknown_0x90c10fe7=data['unknown_0x90c10fe7'],
unknown_0xd8daff1d=data['unknown_0xd8daff1d'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'full_alpha': self.full_alpha,
'fade_down_time': self.fade_down_time,
'fade_up_time': self.fade_up_time,
'start_faded_out': self.start_faded_out,
'color': self.color.to_json(),
'ambient_radius_x': self.ambient_radius_x,
'ambient_radius_y': self.ambient_radius_y,
'ambient_speed': self.ambient_speed,
'ambient_speed_target': self.ambient_speed_target,
'unknown_0x6a111b96': self.unknown_0x6a111b96,
'unknown_0xff226ea3': self.unknown_0xff226ea3,
'unknown_0x2190ab0a': self.unknown_0x2190ab0a.to_json(),
'unknown_0x9f19f0af': self.unknown_0x9f19f0af,
'unknown_0x90c10fe7': self.unknown_0x90c10fe7,
'unknown_0xd8daff1d': self.unknown_0xd8daff1d,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_full_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_down_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_up_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_faded_out(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)
def _decode_ambient_radius_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_radius_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_speed_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6a111b96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xff226ea3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2190ab0a(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x9f19f0af(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x90c10fe7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd8daff1d(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x547b28d5: ('full_alpha', _decode_full_alpha),
0xf977cb35: ('fade_down_time', _decode_fade_down_time),
0xd21d348: ('fade_up_time', _decode_fade_up_time),
0xeb250a0b: ('start_faded_out', _decode_start_faded_out),
0x37c7d09d: ('color', _decode_color),
0x1b9046d6: ('ambient_radius_x', _decode_ambient_radius_x),
0xd0cc9573: ('ambient_radius_y', _decode_ambient_radius_y),
0xf76bcbdd: ('ambient_speed', _decode_ambient_speed),
0x2c4c6785: ('ambient_speed_target', _decode_ambient_speed_target),
0x6a111b96: ('unknown_0x6a111b96', _decode_unknown_0x6a111b96),
0xff226ea3: ('unknown_0xff226ea3', _decode_unknown_0xff226ea3),
0x2190ab0a: ('unknown_0x2190ab0a', _decode_unknown_0x2190ab0a),
0x9f19f0af: ('unknown_0x9f19f0af', _decode_unknown_0x9f19f0af),
0x90c10fe7: ('unknown_0x90c10fe7', _decode_unknown_0x90c10fe7),
0xd8daff1d: ('unknown_0xd8daff1d', _decode_unknown_0xd8daff1d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/FogOverlay.py | 0.606848 | 0.326943 | FogOverlay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class EOLDisplay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
give_item_award: bool = dataclasses.field(default=False)
item_award: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.Banana)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'EOLD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x87\xc8\xb3\x99') # 0x87c8b399
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.give_item_award))
data.write(b'\xe73\x892') # 0xe7338932
data.write(b'\x00\x04') # size
self.item_award.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
give_item_award=data['give_item_award'],
item_award=enums.PlayerItem.from_json(data['item_award']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'give_item_award': self.give_item_award,
'item_award': self.item_award.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_give_item_award(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_item_award(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x87c8b399: ('give_item_award', _decode_give_item_award),
0xe7338932: ('item_award', _decode_item_award),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/EOLDisplay.py | 0.61659 | 0.316422 | EOLDisplay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class BonusRoom(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
use_timer: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
timer_seconds: float = dataclasses.field(default=10.0)
warning_seconds: float = dataclasses.field(default=5.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BONU'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd5i\xadM') # 0xd569ad4d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_timer))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'l\x16\x06!') # 0x6c160621
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.timer_seconds))
data.write(b'{\x1e*\xeb') # 0x7b1e2aeb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.warning_seconds))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
use_timer=data['use_timer'],
auto_start=data['auto_start'],
timer_seconds=data['timer_seconds'],
warning_seconds=data['warning_seconds'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'use_timer': self.use_timer,
'auto_start': self.auto_start,
'timer_seconds': self.timer_seconds,
'warning_seconds': self.warning_seconds,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_use_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_timer_seconds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_warning_seconds(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd569ad4d: ('use_timer', _decode_use_timer),
0x3217dff8: ('auto_start', _decode_auto_start),
0x6c160621: ('timer_seconds', _decode_timer_seconds),
0x7b1e2aeb: ('warning_seconds', _decode_warning_seconds),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BonusRoom.py | 0.630571 | 0.359477 | BonusRoom.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SuspensionBridgeData import SuspensionBridgeData
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SuspensionBridge(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
fsmc: AssetId = dataclasses.field(metadata={'asset_types': ['FSMC']}, default=default_asset_id)
suspension_bridge_data: SuspensionBridgeData = dataclasses.field(default_factory=SuspensionBridgeData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SUSP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b!\xee\xb2') # 0x1b21eeb2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fsmc))
data.write(b'\xe5\x99\x99e') # 0xe5999965
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.suspension_bridge_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
collision_model=data['collision_model'],
animation=AnimationParameters.from_json(data['animation']),
fsmc=data['fsmc'],
suspension_bridge_data=SuspensionBridgeData.from_json(data['suspension_bridge_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'collision_model': self.collision_model,
'animation': self.animation.to_json(),
'fsmc': self.fsmc,
'suspension_bridge_data': self.suspension_bridge_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_fsmc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_suspension_bridge_data(data: typing.BinaryIO, property_size: int):
return SuspensionBridgeData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa3d63f44: ('animation', _decode_animation),
0x1b21eeb2: ('fsmc', _decode_fsmc),
0xe5999965: ('suspension_bridge_data', _decode_suspension_bridge_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SuspensionBridge.py | 0.668231 | 0.299963 | SuspensionBridge.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.CheckpointData import CheckpointData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct24 import UnknownStruct24
@dataclasses.dataclass()
class Checkpoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
checkpoint_data: CheckpointData = dataclasses.field(default_factory=CheckpointData)
layer_list: UnknownStruct24 = dataclasses.field(default_factory=UnknownStruct24)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CKPT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\xa9\x7f\xee') # 0xb9a97fee
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.checkpoint_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Ak\xd9\xeb') # 0x416bd9eb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer_list.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
checkpoint_data=CheckpointData.from_json(data['checkpoint_data']),
layer_list=UnknownStruct24.from_json(data['layer_list']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'checkpoint_data': self.checkpoint_data.to_json(),
'layer_list': self.layer_list.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_checkpoint_data(data: typing.BinaryIO, property_size: int):
return CheckpointData.from_stream(data, property_size)
def _decode_layer_list(data: typing.BinaryIO, property_size: int):
return UnknownStruct24.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb9a97fee: ('checkpoint_data', _decode_checkpoint_data),
0x416bd9eb: ('layer_list', _decode_layer_list),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Checkpoint.py | 0.661048 | 0.352007 | Checkpoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIWaypoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
turn_speed_modifier: float = dataclasses.field(default=1.0)
speed_modifier: float = dataclasses.field(default=1.0)
pause: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIWP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\xb7\x91\xd7') # 0x97b791d7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed_modifier))
data.write(b'8\x8eI\x02') # 0x388e4902
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed_modifier))
data.write(b'\x80\xf7\xe6\x05') # 0x80f7e605
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
turn_speed_modifier=data['turn_speed_modifier'],
speed_modifier=data['speed_modifier'],
pause=data['pause'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'turn_speed_modifier': self.turn_speed_modifier,
'speed_modifier': self.speed_modifier,
'pause': self.pause,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_turn_speed_modifier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed_modifier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pause(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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x97b791d7: ('turn_speed_modifier', _decode_turn_speed_modifier),
0x388e4902: ('speed_modifier', _decode_speed_modifier),
0x80f7e605: ('pause', _decode_pause),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AIWaypoint.py | 0.676834 | 0.369486 | AIWaypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct242 import UnknownStruct242
@dataclasses.dataclass()
class MusicTrack(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct242: UnknownStruct242 = dataclasses.field(default_factory=UnknownStruct242)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MUTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<\x18fl') # 0x3c18666c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct242.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct242=UnknownStruct242.from_json(data['unknown_struct242']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct242': self.unknown_struct242.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct242(data: typing.BinaryIO, property_size: int):
return UnknownStruct242.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3c18666c: ('unknown_struct242', _decode_unknown_struct242),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MusicTrack.py | 0.620852 | 0.362151 | MusicTrack.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class WorldLightFader(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
target_light: float = dataclasses.field(default=1.0)
target_light_rate: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WLIT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfbg\xa2k') # 0xfb67a26b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_light))
data.write(b'#M\xceR') # 0x234dce52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_light_rate))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
target_light=data['target_light'],
target_light_rate=data['target_light_rate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'target_light': self.target_light,
'target_light_rate': self.target_light_rate,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_target_light(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_light_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfb67a26b: ('target_light', _decode_target_light),
0x234dce52: ('target_light_rate', _decode_target_light_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/WorldLightFader.py | 0.673943 | 0.371393 | WorldLightFader.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class RumbleEffect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_rumble: int = dataclasses.field(default=240)
effect: enums.Effect = dataclasses.field(default=enums.Effect.Unknown1)
unknown: Spline = dataclasses.field(default_factory=Spline)
radius: float = dataclasses.field(default=20.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RUMB'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'O\x7f\xec9') # 0x4f7fec39
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_rumble))
data.write(b')]#\x8b') # 0x295d238b
data.write(b'\x00\x04') # size
self.effect.to_stream(data)
data.write(b'\x05\xa4Q\xed') # 0x5a451ed
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'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_rumble=data['flags_rumble'],
effect=enums.Effect.from_json(data['effect']),
unknown=Spline.from_json(data['unknown']),
radius=data['radius'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_rumble': self.flags_rumble,
'effect': self.effect.to_json(),
'unknown': self.unknown.to_json(),
'radius': self.radius,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_rumble(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_effect(data: typing.BinaryIO, property_size: int):
return enums.Effect.from_stream(data)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x4f7fec39: ('flags_rumble', _decode_flags_rumble),
0x295d238b: ('effect', _decode_effect),
0x5a451ed: ('unknown', _decode_unknown),
0x78c507eb: ('radius', _decode_radius),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RumbleEffect.py | 0.648578 | 0.33659 | RumbleEffect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.GuiWidgetProperties import GuiWidgetProperties
@dataclasses.dataclass()
class GuiWidget(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_widget_properties: GuiWidgetProperties = dataclasses.field(default_factory=GuiWidgetProperties)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GWIG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xce\xfa\x1e') # 0x91cefa1e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gui_widget_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
gui_widget_properties=GuiWidgetProperties.from_json(data['gui_widget_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_widget_properties': self.gui_widget_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_gui_widget_properties(data: typing.BinaryIO, property_size: int):
return GuiWidgetProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x91cefa1e: ('gui_widget_properties', _decode_gui_widget_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GuiWidget.py | 0.595963 | 0.323768 | GuiWidget.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class PathControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
path_flags: int = dataclasses.field(default=0)
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
editor_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PCTL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xb9\x7f\x9f') # 0xb0b97f9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.path_flags))
data.write(b' \t\x1bT') # 0x20091b54
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xdd\x86\xe2') # 0xdd86e2
data.write(b'\x00\x10') # size
self.editor_color.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
path_flags=data['path_flags'],
spline_type=SplineType.from_json(data['spline_type']),
editor_color=Color.from_json(data['editor_color']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'path_flags': self.path_flags,
'spline_type': self.spline_type.to_json(),
'editor_color': self.editor_color.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_path_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_editor_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb0b97f9f: ('path_flags', _decode_path_flags),
0x20091b54: ('spline_type', _decode_spline_type),
0xdd86e2: ('editor_color', _decode_editor_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PathControl.py | 0.685844 | 0.341665 | PathControl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class FogVolume(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fog_bob_height: float = dataclasses.field(default=0.0)
fog_bob_freq: float = dataclasses.field(default=1.0)
fog_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOGV'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\r\xffD') # 0xb90dff44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fog_bob_height))
data.write(b'\xf6\x08\xd3\\') # 0xf608d35c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fog_bob_freq))
data.write(b'\xe5x\xc0\xdd') # 0xe578c0dd
data.write(b'\x00\x10') # size
self.fog_color.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
fog_bob_height=data['fog_bob_height'],
fog_bob_freq=data['fog_bob_freq'],
fog_color=Color.from_json(data['fog_color']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'fog_bob_height': self.fog_bob_height,
'fog_bob_freq': self.fog_bob_freq,
'fog_color': self.fog_color.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_fog_bob_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fog_bob_freq(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fog_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb90dff44: ('fog_bob_height', _decode_fog_bob_height),
0xf608d35c: ('fog_bob_freq', _decode_fog_bob_freq),
0xe578c0dd: ('fog_color', _decode_fog_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/FogVolume.py | 0.696371 | 0.32134 | FogVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct143 import UnknownStruct143
@dataclasses.dataclass()
class PlayerActionHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct143: UnknownStruct143 = dataclasses.field(default_factory=UnknownStruct143)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'HINT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbb\xfa\xdeU') # 0xbbfade55
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct143.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct143=UnknownStruct143.from_json(data['unknown_struct143']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct143': self.unknown_struct143.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct143(data: typing.BinaryIO, property_size: int):
return UnknownStruct143.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbbfade55: ('unknown_struct143', _decode_unknown_struct143),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PlayerActionHint.py | 0.628065 | 0.360827 | PlayerActionHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class SurfaceControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
surface_type: enums.SurfaceType = dataclasses.field(default=enums.SurfaceType.Unknown1)
spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SCTL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4+qI') # 0xa42b7149
data.write(b'\x00\x04') # size
self.surface_type.to_stream(data)
data.write(b'\x92-\x15\x1f') # 0x922d151f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
surface_type=enums.SurfaceType.from_json(data['surface_type']),
spline=Spline.from_json(data['spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'surface_type': self.surface_type.to_json(),
'spline': self.spline.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_surface_type(data: typing.BinaryIO, property_size: int):
return enums.SurfaceType.from_stream(data)
def _decode_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa42b7149: ('surface_type', _decode_surface_type),
0x922d151f: ('spline', _decode_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SurfaceControl.py | 0.637257 | 0.350199 | SurfaceControl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PlayerType import PlayerType
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct277 import UnknownStruct277
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 Tutorial(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_parameters: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct6: PlayerType = dataclasses.field(default_factory=PlayerType)
unknown_struct277: UnknownStruct277 = dataclasses.field(default_factory=UnknownStruct277)
offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
activation_distance: float = dataclasses.field(default=10.0)
activation_delay: float = dataclasses.field(default=2.0)
sound_show_tutorial: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
sound_hide_tutorial: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
ignore_player_detection: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TUTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd2\x9c\x03\x1d') # 0xd29c031d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_parameters.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\xab\xb3\xb8') # 0x56abb3b8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\xaamU') # 0x76aa6d55
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct277.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'FGpd') # 0x46477064
data.write(b'\x00\x0c') # size
self.offset.to_stream(data)
data.write(b'\xf9\nO\xe9') # 0xf90a4fe9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.activation_distance))
data.write(b'\xe5\x85\xf1f') # 0xe585f166
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.activation_delay))
data.write(b'Dc\x07\xa9') # 0x446307a9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_show_tutorial))
data.write(b'\x11\xf8E`') # 0x11f84560
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_hide_tutorial))
data.write(b'\x14\xce\xff\x80') # 0x14ceff80
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_player_detection))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_parameters=ActorParameters.from_json(data['actor_parameters']),
unknown_struct6=PlayerType.from_json(data['unknown_struct6']),
unknown_struct277=UnknownStruct277.from_json(data['unknown_struct277']),
offset=Vector.from_json(data['offset']),
activation_distance=data['activation_distance'],
activation_delay=data['activation_delay'],
sound_show_tutorial=data['sound_show_tutorial'],
sound_hide_tutorial=data['sound_hide_tutorial'],
ignore_player_detection=data['ignore_player_detection'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_parameters': self.actor_parameters.to_json(),
'unknown_struct6': self.unknown_struct6.to_json(),
'unknown_struct277': self.unknown_struct277.to_json(),
'offset': self.offset.to_json(),
'activation_distance': self.activation_distance,
'activation_delay': self.activation_delay,
'sound_show_tutorial': self.sound_show_tutorial,
'sound_hide_tutorial': self.sound_hide_tutorial,
'ignore_player_detection': self.ignore_player_detection,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_parameters(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct6(data: typing.BinaryIO, property_size: int):
return PlayerType.from_stream(data, property_size)
def _decode_unknown_struct277(data: typing.BinaryIO, property_size: int):
return UnknownStruct277.from_stream(data, property_size)
def _decode_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_activation_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_activation_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_show_tutorial(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound_hide_tutorial(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_ignore_player_detection(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd29c031d: ('actor_parameters', _decode_actor_parameters),
0x56abb3b8: ('unknown_struct6', _decode_unknown_struct6),
0x76aa6d55: ('unknown_struct277', _decode_unknown_struct277),
0x46477064: ('offset', _decode_offset),
0xf90a4fe9: ('activation_distance', _decode_activation_distance),
0xe585f166: ('activation_delay', _decode_activation_delay),
0x446307a9: ('sound_show_tutorial', _decode_sound_show_tutorial),
0x11f84560: ('sound_hide_tutorial', _decode_sound_hide_tutorial),
0x14ceff80: ('ignore_player_detection', _decode_ignore_player_detection),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Tutorial.py | 0.621771 | 0.319679 | Tutorial.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SpawnPointData import SpawnPointData
@dataclasses.dataclass()
class SpawnPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
spawn_point_data: SpawnPointData = dataclasses.field(default_factory=SpawnPointData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPWN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xac\xbfS@') # 0xacbf5340
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spawn_point_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
spawn_point_data=SpawnPointData.from_json(data['spawn_point_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'spawn_point_data': self.spawn_point_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_spawn_point_data(data: typing.BinaryIO, property_size: int):
return SpawnPointData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xacbf5340: ('spawn_point_data', _decode_spawn_point_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SpawnPoint.py | 0.631708 | 0.403097 | SpawnPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TimeKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TKEY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
time=data['time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44335aff: ('time', _decode_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TimeKeyframe.py | 0.667039 | 0.370112 | TimeKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.dkc_returns.archetypes.MultiModelInformation import MultiModelInformation
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Color import Color
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class MultiModelActor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
multi_model_information: MultiModelInformation = dataclasses.field(default_factory=MultiModelInformation)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
use_mod_inca: bool = dataclasses.field(default=False)
mod_inca_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
mod_inca_amount: Spline = dataclasses.field(default_factory=Spline)
is_solid: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MMDL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptMultiModelActor.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
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'{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'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x19`\x93-') # 0x1960932d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb50\xd7\xde') # 0xb530d7de
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_mod_inca))
data.write(b'\xf8\xdfl\xd2') # 0xf8df6cd2
data.write(b'\x00\x10') # size
self.mod_inca_color.to_stream(data)
data.write(b'\xc20\x11\xd9') # 0xc23011d9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mod_inca_amount.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
collision_model=data['collision_model'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
model=data['model'],
multi_model_information=MultiModelInformation.from_json(data['multi_model_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
use_mod_inca=data['use_mod_inca'],
mod_inca_color=Color.from_json(data['mod_inca_color']),
mod_inca_amount=Spline.from_json(data['mod_inca_amount']),
is_solid=data['is_solid'],
immovable=data['immovable'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'collision_model': self.collision_model,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'model': self.model,
'multi_model_information': self.multi_model_information.to_json(),
'actor_information': self.actor_information.to_json(),
'use_mod_inca': self.use_mod_inca,
'mod_inca_color': self.mod_inca_color.to_json(),
'mod_inca_amount': self.mod_inca_amount.to_json(),
'is_solid': self.is_solid,
'immovable': self.immovable,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_multi_model_information(data: typing.BinaryIO, property_size: int):
return MultiModelInformation.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_use_mod_inca(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_mod_inca_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_mod_inca_amount(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_is_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xfc966dc: ('collision_model', _decode_collision_model),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xc27ffa8f: ('model', _decode_model),
0x1960932d: ('multi_model_information', _decode_multi_model_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb530d7de: ('use_mod_inca', _decode_use_mod_inca),
0xf8df6cd2: ('mod_inca_color', _decode_mod_inca_color),
0xc23011d9: ('mod_inca_amount', _decode_mod_inca_amount),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x1e32523e: ('immovable', _decode_immovable),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MultiModelActor.py | 0.581303 | 0.258782 | MultiModelActor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.BouncyTireData import BouncyTireData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class BouncyTire(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
bouncy_tire_data: BouncyTireData = dataclasses.field(default_factory=BouncyTireData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BTYR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xd5\xbf\xde') # 0xc4d5bfde
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bouncy_tire_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
bouncy_tire_data=BouncyTireData.from_json(data['bouncy_tire_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'bouncy_tire_data': self.bouncy_tire_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_bouncy_tire_data(data: typing.BinaryIO, property_size: int):
return BouncyTireData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc4d5bfde: ('bouncy_tire_data', _decode_bouncy_tire_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BouncyTire.py | 0.665845 | 0.361024 | BouncyTire.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.BossHUD import BossHUD
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PauseHUD import PauseHUD
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct147 import UnknownStruct147
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct156 import UnknownStruct156
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct157 import UnknownStruct157
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct159 import UnknownStruct159
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct162 import UnknownStruct162
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct164 import UnknownStruct164
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct28 import UnknownStruct28
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct36 import UnknownStruct36
@dataclasses.dataclass()
class HUD(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct147: UnknownStruct147 = dataclasses.field(default_factory=UnknownStruct147)
pause_hud: PauseHUD = dataclasses.field(default_factory=PauseHUD)
boss_hud: BossHUD = dataclasses.field(default_factory=BossHUD)
unknown_struct156: UnknownStruct156 = dataclasses.field(default_factory=UnknownStruct156)
unknown_struct157: UnknownStruct157 = dataclasses.field(default_factory=UnknownStruct157)
unknown_struct159: UnknownStruct159 = dataclasses.field(default_factory=UnknownStruct159)
unknown_struct162: UnknownStruct162 = dataclasses.field(default_factory=UnknownStruct162)
unknown_struct164: UnknownStruct164 = dataclasses.field(default_factory=UnknownStruct164)
unknown_struct28_0xc68bc9ec: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct28_0x6bdd8b7a: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct36: UnknownStruct36 = dataclasses.field(default_factory=UnknownStruct36)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'HUDD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']\x9c\x85\xda') # 0x5d9c85da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct147.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10e\x969') # 0x10659639
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pause_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaeA\xee\xd1') # 0xae41eed1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.boss_hud.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\x14\xbd\x82') # 0xb914bd82
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct156.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0bYGA') # 0xb594741
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct157.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\x84\x1cm') # 0x51841c6d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct159.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x10k0\x89') # 0x106b3089
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct162.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<(\x0ed') # 0x3c280e64
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct164.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\x8b\xc9\xec') # 0xc68bc9ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0xc68bc9ec.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'k\xdd\x8bz') # 0x6bdd8b7a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28_0x6bdd8b7a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'?\x88\xe9\x00') # 0x3f88e900
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct36.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct147=UnknownStruct147.from_json(data['unknown_struct147']),
pause_hud=PauseHUD.from_json(data['pause_hud']),
boss_hud=BossHUD.from_json(data['boss_hud']),
unknown_struct156=UnknownStruct156.from_json(data['unknown_struct156']),
unknown_struct157=UnknownStruct157.from_json(data['unknown_struct157']),
unknown_struct159=UnknownStruct159.from_json(data['unknown_struct159']),
unknown_struct162=UnknownStruct162.from_json(data['unknown_struct162']),
unknown_struct164=UnknownStruct164.from_json(data['unknown_struct164']),
unknown_struct28_0xc68bc9ec=UnknownStruct28.from_json(data['unknown_struct28_0xc68bc9ec']),
unknown_struct28_0x6bdd8b7a=UnknownStruct28.from_json(data['unknown_struct28_0x6bdd8b7a']),
unknown_struct36=UnknownStruct36.from_json(data['unknown_struct36']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct147': self.unknown_struct147.to_json(),
'pause_hud': self.pause_hud.to_json(),
'boss_hud': self.boss_hud.to_json(),
'unknown_struct156': self.unknown_struct156.to_json(),
'unknown_struct157': self.unknown_struct157.to_json(),
'unknown_struct159': self.unknown_struct159.to_json(),
'unknown_struct162': self.unknown_struct162.to_json(),
'unknown_struct164': self.unknown_struct164.to_json(),
'unknown_struct28_0xc68bc9ec': self.unknown_struct28_0xc68bc9ec.to_json(),
'unknown_struct28_0x6bdd8b7a': self.unknown_struct28_0x6bdd8b7a.to_json(),
'unknown_struct36': self.unknown_struct36.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct147(data: typing.BinaryIO, property_size: int):
return UnknownStruct147.from_stream(data, property_size)
def _decode_pause_hud(data: typing.BinaryIO, property_size: int):
return PauseHUD.from_stream(data, property_size)
def _decode_boss_hud(data: typing.BinaryIO, property_size: int):
return BossHUD.from_stream(data, property_size)
def _decode_unknown_struct156(data: typing.BinaryIO, property_size: int):
return UnknownStruct156.from_stream(data, property_size)
def _decode_unknown_struct157(data: typing.BinaryIO, property_size: int):
return UnknownStruct157.from_stream(data, property_size)
def _decode_unknown_struct159(data: typing.BinaryIO, property_size: int):
return UnknownStruct159.from_stream(data, property_size)
def _decode_unknown_struct162(data: typing.BinaryIO, property_size: int):
return UnknownStruct162.from_stream(data, property_size)
def _decode_unknown_struct164(data: typing.BinaryIO, property_size: int):
return UnknownStruct164.from_stream(data, property_size)
def _decode_unknown_struct28_0xc68bc9ec(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct28_0x6bdd8b7a(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct36(data: typing.BinaryIO, property_size: int):
return UnknownStruct36.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x5d9c85da: ('unknown_struct147', _decode_unknown_struct147),
0x10659639: ('pause_hud', _decode_pause_hud),
0xae41eed1: ('boss_hud', _decode_boss_hud),
0xb914bd82: ('unknown_struct156', _decode_unknown_struct156),
0xb594741: ('unknown_struct157', _decode_unknown_struct157),
0x51841c6d: ('unknown_struct159', _decode_unknown_struct159),
0x106b3089: ('unknown_struct162', _decode_unknown_struct162),
0x3c280e64: ('unknown_struct164', _decode_unknown_struct164),
0xc68bc9ec: ('unknown_struct28_0xc68bc9ec', _decode_unknown_struct28_0xc68bc9ec),
0x6bdd8b7a: ('unknown_struct28_0x6bdd8b7a', _decode_unknown_struct28_0x6bdd8b7a),
0x3f88e900: ('unknown_struct36', _decode_unknown_struct36),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/HUD.py | 0.519034 | 0.276336 | HUD.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.dkc_returns as enums
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SpecialFunction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
function: enums.Function = dataclasses.field(default=enums.Function.What)
string_parm: str = dataclasses.field(default='')
value_parm: float = dataclasses.field(default=0.0)
value_parm2: float = dataclasses.field(default=0.0)
value_parm3: float = dataclasses.field(default=0.0)
value_parm4: float = dataclasses.field(default=0.0)
int_parm1: int = dataclasses.field(default=0)
int_parm2: int = dataclasses.field(default=0)
inventory_item_parm: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.Banana)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPFN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8\xaf\xcf!') # 0xb8afcf21
data.write(b'\x00\x04') # size
self.function.to_stream(data)
data.write(b'\x9dzWm') # 0x9d7a576d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.string_parm.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'\x19\x02\x80\x99') # 0x19028099
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm))
data.write(b',\x93\xaa\xf5') # 0x2c93aaf5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm2))
data.write(b'\xe7\xcfyP') # 0xe7cf7950
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm3))
data.write(b'\xfa\xcaI\xe8') # 0xfaca49e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm4))
data.write(b'\xa74\xf8\xa5') # 0xa734f8a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.int_parm1))
data.write(b'\xb5\x81WK') # 0xb581574b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.int_parm2))
data.write(b'?\xa1d\xbc') # 0x3fa164bc
data.write(b'\x00\x04') # size
self.inventory_item_parm.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
function=enums.Function.from_json(data['function']),
string_parm=data['string_parm'],
value_parm=data['value_parm'],
value_parm2=data['value_parm2'],
value_parm3=data['value_parm3'],
value_parm4=data['value_parm4'],
int_parm1=data['int_parm1'],
int_parm2=data['int_parm2'],
inventory_item_parm=enums.PlayerItem.from_json(data['inventory_item_parm']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'function': self.function.to_json(),
'string_parm': self.string_parm,
'value_parm': self.value_parm,
'value_parm2': self.value_parm2,
'value_parm3': self.value_parm3,
'value_parm4': self.value_parm4,
'int_parm1': self.int_parm1,
'int_parm2': self.int_parm2,
'inventory_item_parm': self.inventory_item_parm.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_function(data: typing.BinaryIO, property_size: int):
return enums.Function.from_stream(data)
def _decode_string_parm(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_value_parm(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_int_parm1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_int_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_inventory_item_parm(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb8afcf21: ('function', _decode_function),
0x9d7a576d: ('string_parm', _decode_string_parm),
0x19028099: ('value_parm', _decode_value_parm),
0x2c93aaf5: ('value_parm2', _decode_value_parm2),
0xe7cf7950: ('value_parm3', _decode_value_parm3),
0xfaca49e8: ('value_parm4', _decode_value_parm4),
0xa734f8a5: ('int_parm1', _decode_int_parm1),
0xb581574b: ('int_parm2', _decode_int_parm2),
0x3fa164bc: ('inventory_item_parm', _decode_inventory_item_parm),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SpecialFunction.py | 0.599133 | 0.318989 | SpecialFunction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.DynamicLightFalloff import DynamicLightFalloff
from retro_data_structures.properties.dkc_returns.archetypes.DynamicLightIntensity import DynamicLightIntensity
from retro_data_structures.properties.dkc_returns.archetypes.DynamicLightMotionSpline import DynamicLightMotionSpline
from retro_data_structures.properties.dkc_returns.archetypes.DynamicLightParent import DynamicLightParent
from retro_data_structures.properties.dkc_returns.archetypes.DynamicLightSpotlight import DynamicLightSpotlight
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct91 import UnknownStruct91
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct92 import UnknownStruct92
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class DynamicLight(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
light_type: int = dataclasses.field(default=2)
unknown_struct91: UnknownStruct91 = dataclasses.field(default_factory=UnknownStruct91)
unknown_struct92: UnknownStruct92 = dataclasses.field(default_factory=UnknownStruct92)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
intensity: DynamicLightIntensity = dataclasses.field(default_factory=DynamicLightIntensity)
falloff: DynamicLightFalloff = dataclasses.field(default_factory=DynamicLightFalloff)
spotlight: DynamicLightSpotlight = dataclasses.field(default_factory=DynamicLightSpotlight)
motion_spline: DynamicLightMotionSpline = dataclasses.field(default_factory=DynamicLightMotionSpline)
parent: DynamicLightParent = dataclasses.field(default_factory=DynamicLightParent)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DLHT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\n') # 10 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7f\xc4\xe36') # 0x7fc4e336
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.light_type))
data.write(b'\x9a\xc8\x10j') # 0x9ac8106a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct91.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b't\xe9d(') # 0x74e96428
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct92.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'rS\x1e\xde') # 0x72531ede
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.intensity.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\x9bR\xda') # 0x219b52da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.falloff.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95F\xf4I') # 0x9546f449
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spotlight.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x142!8') # 0x14322138
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf74\xdf\x8c') # 0xf734df8c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.parent.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
light_type=data['light_type'],
unknown_struct91=UnknownStruct91.from_json(data['unknown_struct91']),
unknown_struct92=UnknownStruct92.from_json(data['unknown_struct92']),
color=Color.from_json(data['color']),
intensity=DynamicLightIntensity.from_json(data['intensity']),
falloff=DynamicLightFalloff.from_json(data['falloff']),
spotlight=DynamicLightSpotlight.from_json(data['spotlight']),
motion_spline=DynamicLightMotionSpline.from_json(data['motion_spline']),
parent=DynamicLightParent.from_json(data['parent']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'light_type': self.light_type,
'unknown_struct91': self.unknown_struct91.to_json(),
'unknown_struct92': self.unknown_struct92.to_json(),
'color': self.color.to_json(),
'intensity': self.intensity.to_json(),
'falloff': self.falloff.to_json(),
'spotlight': self.spotlight.to_json(),
'motion_spline': self.motion_spline.to_json(),
'parent': self.parent.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_light_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct91(data: typing.BinaryIO, property_size: int):
return UnknownStruct91.from_stream(data, property_size)
def _decode_unknown_struct92(data: typing.BinaryIO, property_size: int):
return UnknownStruct92.from_stream(data, property_size)
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_intensity(data: typing.BinaryIO, property_size: int):
return DynamicLightIntensity.from_stream(data, property_size)
def _decode_falloff(data: typing.BinaryIO, property_size: int):
return DynamicLightFalloff.from_stream(data, property_size)
def _decode_spotlight(data: typing.BinaryIO, property_size: int):
return DynamicLightSpotlight.from_stream(data, property_size)
def _decode_motion_spline(data: typing.BinaryIO, property_size: int):
return DynamicLightMotionSpline.from_stream(data, property_size)
def _decode_parent(data: typing.BinaryIO, property_size: int):
return DynamicLightParent.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7fc4e336: ('light_type', _decode_light_type),
0x9ac8106a: ('unknown_struct91', _decode_unknown_struct91),
0x74e96428: ('unknown_struct92', _decode_unknown_struct92),
0x37c7d09d: ('color', _decode_color),
0x72531ede: ('intensity', _decode_intensity),
0x219b52da: ('falloff', _decode_falloff),
0x9546f449: ('spotlight', _decode_spotlight),
0x14322138: ('motion_spline', _decode_motion_spline),
0xf734df8c: ('parent', _decode_parent),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DynamicLight.py | 0.586523 | 0.351728 | DynamicLight.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.BehaviorsData import BehaviorsData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.GenericCreatureData import GenericCreatureData
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.RetronomeMessage import RetronomeMessage
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct140 import UnknownStruct140
@dataclasses.dataclass()
class GenericCreature(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
generic_creature: GenericCreatureData = dataclasses.field(default_factory=GenericCreatureData)
behaviors: BehaviorsData = dataclasses.field(default_factory=BehaviorsData)
unknown_struct140: UnknownStruct140 = dataclasses.field(default_factory=UnknownStruct140)
retronome_message: RetronomeMessage = dataclasses.field(default_factory=RetronomeMessage)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GCTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x81\xc8>') # 0xbf81c83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c?\xa4\xa9') # 0x633fa4a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.generic_creature.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'U\xa74\x03') # 0x55a73403
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behaviors.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'W\x1e\xb1\xef') # 0x571eb1ef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct140.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89\x91c\x95') # 0x89916395
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.retronome_message.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
generic_creature=GenericCreatureData.from_json(data['generic_creature']),
behaviors=BehaviorsData.from_json(data['behaviors']),
unknown_struct140=UnknownStruct140.from_json(data['unknown_struct140']),
retronome_message=RetronomeMessage.from_json(data['retronome_message']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'generic_creature': self.generic_creature.to_json(),
'behaviors': self.behaviors.to_json(),
'unknown_struct140': self.unknown_struct140.to_json(),
'retronome_message': self.retronome_message.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_data(data: typing.BinaryIO, property_size: int):
return ShadowData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_generic_creature(data: typing.BinaryIO, property_size: int):
return GenericCreatureData.from_stream(data, property_size)
def _decode_behaviors(data: typing.BinaryIO, property_size: int):
return BehaviorsData.from_stream(data, property_size)
def _decode_unknown_struct140(data: typing.BinaryIO, property_size: int):
return UnknownStruct140.from_stream(data, property_size)
def _decode_retronome_message(data: typing.BinaryIO, property_size: int):
return RetronomeMessage.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x633fa4a9: ('generic_creature', _decode_generic_creature),
0x55a73403: ('behaviors', _decode_behaviors),
0x571eb1ef: ('unknown_struct140', _decode_unknown_struct140),
0x89916395: ('retronome_message', _decode_retronome_message),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GenericCreature.py | 0.539226 | 0.361024 | GenericCreature.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ControlCommands import ControlCommands
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PlayerType import PlayerType
@dataclasses.dataclass()
class ControllerAction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
character_type: PlayerType = dataclasses.field(default_factory=PlayerType)
command: ControlCommands = dataclasses.field(default_factory=ControlCommands)
one_shot: bool = dataclasses.field(default=False)
disable_during_cinematics: bool = dataclasses.field(default=False)
auto_press_during_cinematic_skip: bool = dataclasses.field(default=False)
decay_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CNTA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01>5\xfb') # 0x13e35fb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'q\x0f\xe5\xd7') # 0x710fe5d7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.command.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
data.write(b')\xf4F\xfc') # 0x29f446fc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_during_cinematics))
data.write(b'\xc71\xaea') # 0xc731ae61
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_press_during_cinematic_skip))
data.write(b'\xfc\x82\x7fc') # 0xfc827f63
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.decay_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
character_type=PlayerType.from_json(data['character_type']),
command=ControlCommands.from_json(data['command']),
one_shot=data['one_shot'],
disable_during_cinematics=data['disable_during_cinematics'],
auto_press_during_cinematic_skip=data['auto_press_during_cinematic_skip'],
decay_time=data['decay_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'character_type': self.character_type.to_json(),
'command': self.command.to_json(),
'one_shot': self.one_shot,
'disable_during_cinematics': self.disable_during_cinematics,
'auto_press_during_cinematic_skip': self.auto_press_during_cinematic_skip,
'decay_time': self.decay_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_character_type(data: typing.BinaryIO, property_size: int):
return PlayerType.from_stream(data, property_size)
def _decode_command(data: typing.BinaryIO, property_size: int):
return ControlCommands.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_during_cinematics(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_press_during_cinematic_skip(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_decay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x13e35fb: ('character_type', _decode_character_type),
0x710fe5d7: ('command', _decode_command),
0xead7b7bb: ('one_shot', _decode_one_shot),
0x29f446fc: ('disable_during_cinematics', _decode_disable_during_cinematics),
0xc731ae61: ('auto_press_during_cinematic_skip', _decode_auto_press_during_cinematic_skip),
0xfc827f63: ('decay_time', _decode_decay_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ControllerAction.py | 0.621311 | 0.271608 | ControllerAction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class LevelDarkener(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
darken_time: float = dataclasses.field(default=1.0)
darken_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
hide_world_when_fully_drawn: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'LVLD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Iy2\x87') # 0x49793287
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.darken_time))
data.write(b'i\x14c\xfb') # 0x691463fb
data.write(b'\x00\x10') # size
self.darken_color.to_stream(data)
data.write(b'\x89}6\x16') # 0x897d3616
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hide_world_when_fully_drawn))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
darken_time=data['darken_time'],
darken_color=Color.from_json(data['darken_color']),
hide_world_when_fully_drawn=data['hide_world_when_fully_drawn'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'darken_time': self.darken_time,
'darken_color': self.darken_color.to_json(),
'hide_world_when_fully_drawn': self.hide_world_when_fully_drawn,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_darken_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_darken_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_hide_world_when_fully_drawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x49793287: ('darken_time', _decode_darken_time),
0x691463fb: ('darken_color', _decode_darken_color),
0x897d3616: ('hide_world_when_fully_drawn', _decode_hide_world_when_fully_drawn),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/LevelDarkener.py | 0.684264 | 0.354796 | LevelDarkener.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class SplineModifierVolume(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SVOL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'z\xf6\xf1b') # 0x7af6f162
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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown=Spline.from_json(data['unknown']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7af6f162: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SplineModifierVolume.py | 0.617628 | 0.343837 | SplineModifierVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.TidalWaveData import TidalWaveData
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class TidalWave(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
tidal_wave_data: TidalWaveData = dataclasses.field(default_factory=TidalWaveData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TIDE'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c^\x15\xc9') # 0x8c5e15c9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tidal_wave_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
tidal_wave_data=TidalWaveData.from_json(data['tidal_wave_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'character_animation_information': self.character_animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'tidal_wave_data': self.tidal_wave_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_tidal_wave_data(data: typing.BinaryIO, property_size: int):
return TidalWaveData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0x8c5e15c9: ('tidal_wave_data', _decode_tidal_wave_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/TidalWave.py | 0.62681 | 0.309402 | TidalWave.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class AreaAttributes(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
need_sky: bool = dataclasses.field(default=False)
environment_group_sound: int = dataclasses.field(default=0)
normal_lighting: float = dataclasses.field(default=1.0)
override_sky: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
use_override_sky: bool = dataclasses.field(default=True)
unknown: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'REAA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xd4\xbe\xe7') # 0x95d4bee7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.need_sky))
data.write(b'V&>5') # 0x56263e35
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.environment_group_sound))
data.write(b'\xba_\x80\x1e') # 0xba5f801e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_lighting))
data.write(b'\xd2\x08\xc9\xfa') # 0xd208c9fa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.override_sky))
data.write(b')DS\x02') # 0x29445302
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_override_sky))
data.write(b'\xe3Bb\x06') # 0xe3426206
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
need_sky=data['need_sky'],
environment_group_sound=data['environment_group_sound'],
normal_lighting=data['normal_lighting'],
override_sky=data['override_sky'],
use_override_sky=data['use_override_sky'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'need_sky': self.need_sky,
'environment_group_sound': self.environment_group_sound,
'normal_lighting': self.normal_lighting,
'override_sky': self.override_sky,
'use_override_sky': self.use_override_sky,
'unknown': self.unknown,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_need_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_environment_group_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_normal_lighting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_override_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_use_override_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x95d4bee7: ('need_sky', _decode_need_sky),
0x56263e35: ('environment_group_sound', _decode_environment_group_sound),
0xba5f801e: ('normal_lighting', _decode_normal_lighting),
0xd208c9fa: ('override_sky', _decode_override_sky),
0x29445302: ('use_override_sky', _decode_use_override_sky),
0xe3426206: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AreaAttributes.py | 0.651022 | 0.312082 | AreaAttributes.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.DamageEffectData import DamageEffectData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class DamageEffect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage_effect_data: DamageEffectData = dataclasses.field(default_factory=DamageEffectData)
@classmethod
def game(cls) -> Game:
return Game.DKC_RETURNS
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DMGE'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xf2r\xdd') # 0xeaf272dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_effect_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage_effect_data=DamageEffectData.from_json(data['damage_effect_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage_effect_data': self.damage_effect_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage_effect_data(data: typing.BinaryIO, property_size: int):
return DamageEffectData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xeaf272dd: ('damage_effect_data', _decode_damage_effect_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DamageEffect.py | 0.634883 | 0.364947 | DamageEffect.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.