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
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.archetypes.UnknownStruct11 import UnknownStruct11
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct12 import UnknownStruct12
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct16 import UnknownStruct16
@dataclasses.dataclass()
class Acoustics(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
is_global: bool = dataclasses.field(default=False)
exclude_listener: bool = dataclasses.field(default=False)
start_incremented: bool = dataclasses.field(default=False)
auto_increment: bool = dataclasses.field(default=True)
auto_decrement: bool = dataclasses.field(default=True)
effect_volume: float = dataclasses.field(default=1.0)
effect_type: enums.EffectType = dataclasses.field(default=enums.EffectType.Unknown1)
unknown_struct11: UnknownStruct11 = dataclasses.field(default_factory=UnknownStruct11)
unknown_struct12: UnknownStruct12 = dataclasses.field(default_factory=UnknownStruct12)
unknown_struct16: UnknownStruct16 = dataclasses.field(default_factory=UnknownStruct16)
@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 'ACOU'
@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'v\\\xae\x8c') # 0x765cae8c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_global))
data.write(b'\xc7\x8b\x91\xfa') # 0xc78b91fa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.exclude_listener))
data.write(b'\xa6\xbc\xdf\x8e') # 0xa6bcdf8e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_incremented))
data.write(b'\x11\xaa\x18K') # 0x11aa184b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_increment))
data.write(b"'\x14\xdc;") # 0x2714dc3b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_decrement))
data.write(b'Z8\xa0\x8d') # 0x5a38a08d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.effect_volume))
data.write(b'\xe9\xad(j') # 0xe9ad286a
data.write(b'\x00\x04') # size
self.effect_type.to_stream(data)
data.write(b'\xa3\x83\xe1\x0b') # 0xa383e10b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct11.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'e0\xe9\xcf') # 0x6530e9cf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct12.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\xc9\xda5') # 0x3bc9da35
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct16.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']),
is_global=data['is_global'],
exclude_listener=data['exclude_listener'],
start_incremented=data['start_incremented'],
auto_increment=data['auto_increment'],
auto_decrement=data['auto_decrement'],
effect_volume=data['effect_volume'],
effect_type=enums.EffectType.from_json(data['effect_type']),
unknown_struct11=UnknownStruct11.from_json(data['unknown_struct11']),
unknown_struct12=UnknownStruct12.from_json(data['unknown_struct12']),
unknown_struct16=UnknownStruct16.from_json(data['unknown_struct16']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'is_global': self.is_global,
'exclude_listener': self.exclude_listener,
'start_incremented': self.start_incremented,
'auto_increment': self.auto_increment,
'auto_decrement': self.auto_decrement,
'effect_volume': self.effect_volume,
'effect_type': self.effect_type.to_json(),
'unknown_struct11': self.unknown_struct11.to_json(),
'unknown_struct12': self.unknown_struct12.to_json(),
'unknown_struct16': self.unknown_struct16.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_is_global(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_exclude_listener(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_start_incremented(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_increment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_decrement(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_effect_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_effect_type(data: typing.BinaryIO, property_size: int):
return enums.EffectType.from_stream(data)
def _decode_unknown_struct11(data: typing.BinaryIO, property_size: int):
return UnknownStruct11.from_stream(data, property_size)
def _decode_unknown_struct12(data: typing.BinaryIO, property_size: int):
return UnknownStruct12.from_stream(data, property_size)
def _decode_unknown_struct16(data: typing.BinaryIO, property_size: int):
return UnknownStruct16.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),
0x765cae8c: ('is_global', _decode_is_global),
0xc78b91fa: ('exclude_listener', _decode_exclude_listener),
0xa6bcdf8e: ('start_incremented', _decode_start_incremented),
0x11aa184b: ('auto_increment', _decode_auto_increment),
0x2714dc3b: ('auto_decrement', _decode_auto_decrement),
0x5a38a08d: ('effect_volume', _decode_effect_volume),
0xe9ad286a: ('effect_type', _decode_effect_type),
0xa383e10b: ('unknown_struct11', _decode_unknown_struct11),
0x6530e9cf: ('unknown_struct12', _decode_unknown_struct12),
0x3bc9da35: ('unknown_struct16', _decode_unknown_struct16),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Acoustics.py | 0.582372 | 0.295563 | Acoustics.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.UnknownStruct298 import UnknownStruct298
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class OceanWave(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct298: UnknownStruct298 = dataclasses.field(default_factory=UnknownStruct298)
@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 'WAVE'
@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'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
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'|\xf4y\x0f') # 0x7cf4790f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct298.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']),
model=data['model'],
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct298=UnknownStruct298.from_json(data['unknown_struct298']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'model': self.model,
'actor_information': self.actor_information.to_json(),
'unknown_struct298': self.unknown_struct298.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_model(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_unknown_struct298(data: typing.BinaryIO, property_size: int):
return UnknownStruct298.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),
0xc27ffa8f: ('model', _decode_model),
0x7e397fed: ('actor_information', _decode_actor_information),
0x7cf4790f: ('unknown_struct298', _decode_unknown_struct298),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/OceanWave.py | 0.666822 | 0.284388 | OceanWave.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.Data import Data
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class BeatUpHandler(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
data: Data = dataclasses.field(default_factory=Data)
@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 'BUHA'
@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'P"\x83d') # 0x50228364
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.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']),
data=Data.from_json(data['data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'data': self.data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_data(data: typing.BinaryIO, property_size: int):
return Data.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),
0x50228364: ('data', _decode_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BeatUpHandler.py | 0.617397 | 0.386937 | BeatUpHandler.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 LightVolume(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
num_subdivisions: int = dataclasses.field(default=10)
@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 'LVOL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'~CY\xd1') # 0x7e4359d1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_subdivisions))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
color=Color.from_json(data['color']),
num_subdivisions=data['num_subdivisions'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'color': self.color.to_json(),
'num_subdivisions': self.num_subdivisions,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_num_subdivisions(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),
0x37c7d09d: ('color', _decode_color),
0x7e4359d1: ('num_subdivisions', _decode_num_subdivisions),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/LightVolume.py | 0.643889 | 0.3325 | LightVolume.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 SoundModifierData(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=5.0)
fade_in_time: float = dataclasses.field(default=0.0)
fade_out_time: float = dataclasses.field(default=0.0)
auto_start: bool = dataclasses.field(default=False)
loop: bool = dataclasses.field(default=False)
loop_platform_contribution: bool = dataclasses.field(default=False)
invert_platform_contribution: bool = dataclasses.field(default=False)
volume: Spline = dataclasses.field(default_factory=Spline)
pan: Spline = dataclasses.field(default_factory=Spline)
surround_pan: Spline = dataclasses.field(default_factory=Spline)
pitch: Spline = dataclasses.field(default_factory=Spline)
low_pass: 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 'SNMD'
@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'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\xa0\x93\x98E') # 0xa0939845
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_platform_contribution))
data.write(b'V-a"') # 0x562d6122
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.invert_platform_contribution))
data.write(b'\xf3\xfb\xe4\x84') # 0xf3fbe484
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(X\xc9\xf0') # 0x2858c9f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\x13\x19\x8f') # 0x5113198f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surround_pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0er\x7f\xc4') # 0xe727fc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd3\x04\x9e\x04') # 0xd3049e04
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.low_pass.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']),
time=data['time'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
auto_start=data['auto_start'],
loop=data['loop'],
loop_platform_contribution=data['loop_platform_contribution'],
invert_platform_contribution=data['invert_platform_contribution'],
volume=Spline.from_json(data['volume']),
pan=Spline.from_json(data['pan']),
surround_pan=Spline.from_json(data['surround_pan']),
pitch=Spline.from_json(data['pitch']),
low_pass=Spline.from_json(data['low_pass']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'auto_start': self.auto_start,
'loop': self.loop,
'loop_platform_contribution': self.loop_platform_contribution,
'invert_platform_contribution': self.invert_platform_contribution,
'volume': self.volume.to_json(),
'pan': self.pan.to_json(),
'surround_pan': self.surround_pan.to_json(),
'pitch': self.pitch.to_json(),
'low_pass': self.low_pass.to_json(),
}
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]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_start(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_platform_contribution(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_invert_platform_contribution(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pan(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_surround_pan(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_low_pass(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),
0x44335aff: ('time', _decode_time),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0x3217dff8: ('auto_start', _decode_auto_start),
0xeda47ff6: ('loop', _decode_loop),
0xa0939845: ('loop_platform_contribution', _decode_loop_platform_contribution),
0x562d6122: ('invert_platform_contribution', _decode_invert_platform_contribution),
0xf3fbe484: ('volume', _decode_volume),
0x2858c9f0: ('pan', _decode_pan),
0x5113198f: ('surround_pan', _decode_surround_pan),
0xe727fc4: ('pitch', _decode_pitch),
0xd3049e04: ('low_pass', _decode_low_pass),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SoundModifierData.py | 0.583678 | 0.360658 | SoundModifierData.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.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct import UnknownStruct
@dataclasses.dataclass()
class Rambi(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)
kong_data: KongData = dataclasses.field(default_factory=KongData)
@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 'RMBI'
@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'\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'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)
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']),
kong_data=KongData.from_json(data['kong_data']),
)
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(),
'kong_data': self.kong_data.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_kong_data(data: typing.BinaryIO, property_size: int):
return KongData.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),
0x6f7438cf: ('kong_data', _decode_kong_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Rambi.py | 0.604983 | 0.354545 | Rambi.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 HUDProxy(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 'HUDP'
@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/HUDProxy.py | 0.601477 | 0.356615 | HUDProxy.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
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class GuiSlider(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_widget_properties: GuiWidgetProperties = dataclasses.field(default_factory=GuiWidgetProperties)
min_value: float = dataclasses.field(default=0.0)
max_value: float = dataclasses.field(default=255.0)
increment: float = dataclasses.field(default=1.0)
slide_speed: float = dataclasses.field(default=1.0)
slide_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
slide_sound_volume: int = dataclasses.field(default=127)
@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 'GSLD'
@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, 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)
data.write(b',\xcb\xbd\xfe') # 0x2ccbbdfe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_value))
data.write(b'l\x84\xc5\x88') # 0x6c84c588
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_value))
data.write(b'\x8ah\xdbR') # 0x8a68db52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.increment))
data.write(b'\xed\xb6\x06+') # 0xedb6062b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_speed))
data.write(b'+y\xea\x93') # 0x2b79ea93
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.slide_sound))
data.write(b' \xdd\xb6a') # 0x20ddb661
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.slide_sound_volume))
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']),
min_value=data['min_value'],
max_value=data['max_value'],
increment=data['increment'],
slide_speed=data['slide_speed'],
slide_sound=data['slide_sound'],
slide_sound_volume=data['slide_sound_volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_widget_properties': self.gui_widget_properties.to_json(),
'min_value': self.min_value,
'max_value': self.max_value,
'increment': self.increment,
'slide_speed': self.slide_speed,
'slide_sound': self.slide_sound,
'slide_sound_volume': self.slide_sound_volume,
}
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)
def _decode_min_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_increment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_slide_sound_volume(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),
0x91cefa1e: ('gui_widget_properties', _decode_gui_widget_properties),
0x2ccbbdfe: ('min_value', _decode_min_value),
0x6c84c588: ('max_value', _decode_max_value),
0x8a68db52: ('increment', _decode_increment),
0xedb6062b: ('slide_speed', _decode_slide_speed),
0x2b79ea93: ('slide_sound', _decode_slide_sound),
0x20ddb661: ('slide_sound_volume', _decode_slide_sound_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GuiSlider.py | 0.607547 | 0.306715 | GuiSlider.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.RambiCrateData import RambiCrateData
@dataclasses.dataclass()
class RambiCrate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
rambi_crate_data: RambiCrateData = dataclasses.field(default_factory=RambiCrateData)
@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 'RACR'
@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'\xdde\xd9\xb6') # 0xdd65d9b6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rambi_crate_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']),
rambi_crate_data=RambiCrateData.from_json(data['rambi_crate_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'rambi_crate_data': self.rambi_crate_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_rambi_crate_data(data: typing.BinaryIO, property_size: int):
return RambiCrateData.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),
0xdd65d9b6: ('rambi_crate_data', _decode_rambi_crate_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RambiCrate.py | 0.640636 | 0.3217 | RambiCrate.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 Timer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=5.0)
random_adjust: float = dataclasses.field(default=0.0)
auto_start: bool = dataclasses.field(default=False)
loop: 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 'TIMR'
@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'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
data.write(b':\xd3\x9b1') # 0x3ad39b31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_adjust))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
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'],
random_adjust=data['random_adjust'],
auto_start=data['auto_start'],
loop=data['loop'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
'random_adjust': self.random_adjust,
'auto_start': self.auto_start,
'loop': self.loop,
}
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]
def _decode_random_adjust(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_start(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]
_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),
0x3ad39b31: ('random_adjust', _decode_random_adjust),
0x3217dff8: ('auto_start', _decode_auto_start),
0xeda47ff6: ('loop', _decode_loop),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Timer.py | 0.625095 | 0.3628 | Timer.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 LODController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0x00b17e5f: int = dataclasses.field(default=1)
model01: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance01: float = dataclasses.field(default=0.0)
model02: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance02: float = dataclasses.field(default=0.0)
model03: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance03: float = dataclasses.field(default=0.0)
model04: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance04: float = dataclasses.field(default=0.0)
model05: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance05: float = dataclasses.field(default=0.0)
model06: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance06: float = dataclasses.field(default=0.0)
model07: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance07: float = dataclasses.field(default=0.0)
model08: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance08: float = dataclasses.field(default=0.0)
model09: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance09: float = dataclasses.field(default=0.0)
model10: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance10: float = dataclasses.field(default=0.0)
unknown_0xb67e3bf9: 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 'LODC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptLODController.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\x17') # 23 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'\x00\xb1~_') # 0xb17e5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x00b17e5f))
data.write(b'\x03\xbe\xe4~') # 0x3bee47e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model01))
data.write(b'\xa1\x01\x8e\xf9') # 0xa1018ef9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance01))
data.write(b'\x85*\x96\xd0') # 0x852a96d0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model02))
data.write(b"'\x95\xfcW") # 0x2795fc57
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance02))
data.write(b'NvEu') # 0x4e764575
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model03))
data.write(b'\xec\xc9/\xf2') # 0xecc92ff2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance03))
data.write(b'Ssu\xcd') # 0x537375cd
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model04))
data.write(b'\xf1\xcc\x1fJ') # 0xf1cc1f4a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance04))
data.write(b'\x98/\xa6h') # 0x982fa668
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model05))
data.write(b':\x90\xcc\xef') # 0x3a90ccef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance05))
data.write(b'\x1e\xbb\xd4\xc6') # 0x1ebbd4c6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model06))
data.write(b'\xbc\x04\xbeA') # 0xbc04be41
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance06))
data.write(b'\xd5\xe7\x07c') # 0xd5e70763
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model07))
data.write(b'wXm\xe4') # 0x77586de4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance07))
data.write(b'$\xb1\xb5\xb6') # 0x24b1b5b6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model08))
data.write(b'\x86\x0e\xdf1') # 0x860edf31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance08))
data.write(b'\xef\xedf\x13') # 0xefed6613
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model09))
data.write(b'MR\x0c\x94') # 0x4d520c94
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance09))
data.write(b'n\x95<o') # 0x6e953c6f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model10))
data.write(b'\xcc*V\xe8') # 0xcc2a56e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance10))
data.write(b'\xb6~;\xf9') # 0xb67e3bf9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb67e3bf9))
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_0x00b17e5f=data['unknown_0x00b17e5f'],
model01=data['model01'],
distance01=data['distance01'],
model02=data['model02'],
distance02=data['distance02'],
model03=data['model03'],
distance03=data['distance03'],
model04=data['model04'],
distance04=data['distance04'],
model05=data['model05'],
distance05=data['distance05'],
model06=data['model06'],
distance06=data['distance06'],
model07=data['model07'],
distance07=data['distance07'],
model08=data['model08'],
distance08=data['distance08'],
model09=data['model09'],
distance09=data['distance09'],
model10=data['model10'],
distance10=data['distance10'],
unknown_0xb67e3bf9=data['unknown_0xb67e3bf9'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0x00b17e5f': self.unknown_0x00b17e5f,
'model01': self.model01,
'distance01': self.distance01,
'model02': self.model02,
'distance02': self.distance02,
'model03': self.model03,
'distance03': self.distance03,
'model04': self.model04,
'distance04': self.distance04,
'model05': self.model05,
'distance05': self.distance05,
'model06': self.model06,
'distance06': self.distance06,
'model07': self.model07,
'distance07': self.distance07,
'model08': self.model08,
'distance08': self.distance08,
'model09': self.model09,
'distance09': self.distance09,
'model10': self.model10,
'distance10': self.distance10,
'unknown_0xb67e3bf9': self.unknown_0xb67e3bf9,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0x00b17e5f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_model01(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance01(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model02(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance02(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model03(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance03(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model04(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance04(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model05(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance05(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model06(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance06(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model07(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance07(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model08(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance08(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model09(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance09(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model10(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb67e3bf9(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),
0xb17e5f: ('unknown_0x00b17e5f', _decode_unknown_0x00b17e5f),
0x3bee47e: ('model01', _decode_model01),
0xa1018ef9: ('distance01', _decode_distance01),
0x852a96d0: ('model02', _decode_model02),
0x2795fc57: ('distance02', _decode_distance02),
0x4e764575: ('model03', _decode_model03),
0xecc92ff2: ('distance03', _decode_distance03),
0x537375cd: ('model04', _decode_model04),
0xf1cc1f4a: ('distance04', _decode_distance04),
0x982fa668: ('model05', _decode_model05),
0x3a90ccef: ('distance05', _decode_distance05),
0x1ebbd4c6: ('model06', _decode_model06),
0xbc04be41: ('distance06', _decode_distance06),
0xd5e70763: ('model07', _decode_model07),
0x77586de4: ('distance07', _decode_distance07),
0x24b1b5b6: ('model08', _decode_model08),
0x860edf31: ('distance08', _decode_distance08),
0xefed6613: ('model09', _decode_model09),
0x4d520c94: ('distance09', _decode_distance09),
0x6e953c6f: ('model10', _decode_model10),
0xcc2a56e8: ('distance10', _decode_distance10),
0xb67e3bf9: ('unknown_0xb67e3bf9', _decode_unknown_0xb67e3bf9),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/LODController.py | 0.61115 | 0.237211 | LODController.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.UnknownStruct267 import UnknownStruct267
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct268 import UnknownStruct268
@dataclasses.dataclass()
class Spinner(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: bool = dataclasses.field(default=False)
unknown_struct267: UnknownStruct267 = dataclasses.field(default_factory=UnknownStruct267)
unknown_struct268: UnknownStruct268 = dataclasses.field(default_factory=UnknownStruct268)
@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 'SPIN'
@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'\x11\xe0\xab\x90') # 0x11e0ab90
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\xba\x84\xf2>') # 0xba84f23e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct267.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2C\xdf\x95') # 0xc243df95
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct268.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=data['unknown'],
unknown_struct267=UnknownStruct267.from_json(data['unknown_struct267']),
unknown_struct268=UnknownStruct268.from_json(data['unknown_struct268']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown,
'unknown_struct267': self.unknown_struct267.to_json(),
'unknown_struct268': self.unknown_struct268.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 struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct267(data: typing.BinaryIO, property_size: int):
return UnknownStruct267.from_stream(data, property_size)
def _decode_unknown_struct268(data: typing.BinaryIO, property_size: int):
return UnknownStruct268.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),
0x11e0ab90: ('unknown', _decode_unknown),
0xba84f23e: ('unknown_struct267', _decode_unknown_struct267),
0xc243df95: ('unknown_struct268', _decode_unknown_struct268),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Spinner.py | 0.630116 | 0.327064 | Spinner.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.MineCartData import MineCartData
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.PlayerCommonData import PlayerCommonData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerJumpData import PlayerJumpData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMountData import PlayerMountData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMountRiderList import PlayerMountRiderList
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMultiKillRewardData import PlayerMultiKillRewardData
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct import UnknownStruct
@dataclasses.dataclass()
class MineCart(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct: UnknownStruct = dataclasses.field(default_factory=UnknownStruct)
common: PlayerCommonData = dataclasses.field(default_factory=PlayerCommonData)
jump_data: PlayerJumpData = dataclasses.field(default_factory=PlayerJumpData)
multi_kill_reward_data: PlayerMultiKillRewardData = dataclasses.field(default_factory=PlayerMultiKillRewardData)
mount_data: PlayerMountData = dataclasses.field(default_factory=PlayerMountData)
rider_list_data: PlayerMountRiderList = dataclasses.field(default_factory=PlayerMountRiderList)
mine_cart_data: MineCartData = dataclasses.field(default_factory=MineCartData)
@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 'CART'
@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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_radius': 0.699999988079071, 'collision_height': 1.0})
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'<8I\x8d') # 0x3c38498d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.common.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf0{\xecm') # 0xf07bec6d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jump_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x98\xef\xc8c') # 0x98efc863
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_kill_reward_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\x8e[\xd8') # 0x978e5bd8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mount_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7fh\x14\x11') # 0x7f681411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rider_list_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd72i\x12') # 0xd7326912
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mine_cart_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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct=UnknownStruct.from_json(data['unknown_struct']),
common=PlayerCommonData.from_json(data['common']),
jump_data=PlayerJumpData.from_json(data['jump_data']),
multi_kill_reward_data=PlayerMultiKillRewardData.from_json(data['multi_kill_reward_data']),
mount_data=PlayerMountData.from_json(data['mount_data']),
rider_list_data=PlayerMountRiderList.from_json(data['rider_list_data']),
mine_cart_data=MineCartData.from_json(data['mine_cart_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct': self.unknown_struct.to_json(),
'common': self.common.to_json(),
'jump_data': self.jump_data.to_json(),
'multi_kill_reward_data': self.multi_kill_reward_data.to_json(),
'mount_data': self.mount_data.to_json(),
'rider_list_data': self.rider_list_data.to_json(),
'mine_cart_data': self.mine_cart_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_radius': 0.699999988079071, 'collision_height': 1.0})
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_common(data: typing.BinaryIO, property_size: int):
return PlayerCommonData.from_stream(data, property_size)
def _decode_jump_data(data: typing.BinaryIO, property_size: int):
return PlayerJumpData.from_stream(data, property_size)
def _decode_multi_kill_reward_data(data: typing.BinaryIO, property_size: int):
return PlayerMultiKillRewardData.from_stream(data, property_size)
def _decode_mount_data(data: typing.BinaryIO, property_size: int):
return PlayerMountData.from_stream(data, property_size)
def _decode_rider_list_data(data: typing.BinaryIO, property_size: int):
return PlayerMountRiderList.from_stream(data, property_size)
def _decode_mine_cart_data(data: typing.BinaryIO, property_size: int):
return MineCartData.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),
0xb3774750: ('patterned', _decode_patterned),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0x63f638: ('unknown_struct', _decode_unknown_struct),
0x3c38498d: ('common', _decode_common),
0xf07bec6d: ('jump_data', _decode_jump_data),
0x98efc863: ('multi_kill_reward_data', _decode_multi_kill_reward_data),
0x978e5bd8: ('mount_data', _decode_mount_data),
0x7f681411: ('rider_list_data', _decode_rider_list_data),
0xd7326912: ('mine_cart_data', _decode_mine_cart_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MineCart.py | 0.54359 | 0.293906 | MineCart.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 DamageArea(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@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 'DMGA'
@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'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)
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']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
}
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)
_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),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DamageArea.py | 0.619932 | 0.35474 | DamageArea.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.UnknownStruct141 import UnknownStruct141
@dataclasses.dataclass()
class GameManager(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct141: UnknownStruct141 = dataclasses.field(default_factory=UnknownStruct141)
@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 'GMGR'
@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'N\x92\xc6\r') # 0x4e92c60d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct141.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_struct141=UnknownStruct141.from_json(data['unknown_struct141']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct141': self.unknown_struct141.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct141(data: typing.BinaryIO, property_size: int):
return UnknownStruct141.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),
0x4e92c60d: ('unknown_struct141', _decode_unknown_struct141),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/GameManager.py | 0.619586 | 0.35209 | GameManager.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.Vector2f import Vector2f
from retro_data_structures.properties.dkc_returns.core.Color import Color
@dataclasses.dataclass()
class DistanceFog(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0x88e8d530: int = dataclasses.field(default=3630416747) # Choice
mode: int = dataclasses.field(default=0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
near_plane_distance: float = dataclasses.field(default=30.0)
far_plane_distance: float = dataclasses.field(default=100.0)
color_rate: float = dataclasses.field(default=0.0)
unknown_0x685255a5: float = dataclasses.field(default=0.0)
unknown_0x7869a2b0: float = dataclasses.field(default=0.0)
force_settings: bool = dataclasses.field(default=False)
is_two_sided: bool = dataclasses.field(default=False)
unknown_0xb7246843: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
vector2f_0x520d1dd5: Vector2f = dataclasses.field(default_factory=Vector2f)
unknown_0xbc86052a: float = dataclasses.field(default=0.0)
vector2f_0xfba31a97: Vector2f = dataclasses.field(default_factory=Vector2f)
@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 'DFOG'
@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\x0f') # 15 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'\x88\xe8\xd50') # 0x88e8d530
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x88e8d530))
data.write(b'\t\xadc\xde') # 0x9ad63de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.mode))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\x8f\xc4\xdb\xe8') # 0x8fc4dbe8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.near_plane_distance))
data.write(b'\x8b\xc3W\xff') # 0x8bc357ff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_plane_distance))
data.write(b")\xabG'") # 0x29ab4727
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.color_rate))
data.write(b'hRU\xa5') # 0x685255a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x685255a5))
data.write(b'xi\xa2\xb0') # 0x7869a2b0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7869a2b0))
data.write(b'\xc5\x93[g') # 0xc5935b67
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_settings))
data.write(b'\xb5\xd1\xef\x02') # 0xb5d1ef02
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_two_sided))
data.write(b'\xb7$hC') # 0xb7246843
data.write(b'\x00\x10') # size
self.unknown_0xb7246843.to_stream(data)
data.write(b'R\r\x1d\xd5') # 0x520d1dd5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vector2f_0x520d1dd5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\x86\x05*') # 0xbc86052a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbc86052a))
data.write(b'\xfb\xa3\x1a\x97') # 0xfba31a97
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vector2f_0xfba31a97.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_0x88e8d530=data['unknown_0x88e8d530'],
mode=data['mode'],
color=Color.from_json(data['color']),
near_plane_distance=data['near_plane_distance'],
far_plane_distance=data['far_plane_distance'],
color_rate=data['color_rate'],
unknown_0x685255a5=data['unknown_0x685255a5'],
unknown_0x7869a2b0=data['unknown_0x7869a2b0'],
force_settings=data['force_settings'],
is_two_sided=data['is_two_sided'],
unknown_0xb7246843=Color.from_json(data['unknown_0xb7246843']),
vector2f_0x520d1dd5=Vector2f.from_json(data['vector2f_0x520d1dd5']),
unknown_0xbc86052a=data['unknown_0xbc86052a'],
vector2f_0xfba31a97=Vector2f.from_json(data['vector2f_0xfba31a97']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0x88e8d530': self.unknown_0x88e8d530,
'mode': self.mode,
'color': self.color.to_json(),
'near_plane_distance': self.near_plane_distance,
'far_plane_distance': self.far_plane_distance,
'color_rate': self.color_rate,
'unknown_0x685255a5': self.unknown_0x685255a5,
'unknown_0x7869a2b0': self.unknown_0x7869a2b0,
'force_settings': self.force_settings,
'is_two_sided': self.is_two_sided,
'unknown_0xb7246843': self.unknown_0xb7246843.to_json(),
'vector2f_0x520d1dd5': self.vector2f_0x520d1dd5.to_json(),
'unknown_0xbc86052a': self.unknown_0xbc86052a,
'vector2f_0xfba31a97': self.vector2f_0xfba31a97.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_unknown_0x88e8d530(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_near_plane_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_plane_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_color_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x685255a5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7869a2b0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_force_settings(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_two_sided(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb7246843(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_vector2f_0x520d1dd5(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
def _decode_unknown_0xbc86052a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vector2f_0xfba31a97(data: typing.BinaryIO, property_size: int):
return Vector2f.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),
0x88e8d530: ('unknown_0x88e8d530', _decode_unknown_0x88e8d530),
0x9ad63de: ('mode', _decode_mode),
0x37c7d09d: ('color', _decode_color),
0x8fc4dbe8: ('near_plane_distance', _decode_near_plane_distance),
0x8bc357ff: ('far_plane_distance', _decode_far_plane_distance),
0x29ab4727: ('color_rate', _decode_color_rate),
0x685255a5: ('unknown_0x685255a5', _decode_unknown_0x685255a5),
0x7869a2b0: ('unknown_0x7869a2b0', _decode_unknown_0x7869a2b0),
0xc5935b67: ('force_settings', _decode_force_settings),
0xb5d1ef02: ('is_two_sided', _decode_is_two_sided),
0xb7246843: ('unknown_0xb7246843', _decode_unknown_0xb7246843),
0x520d1dd5: ('vector2f_0x520d1dd5', _decode_vector2f_0x520d1dd5),
0xbc86052a: ('unknown_0xbc86052a', _decode_unknown_0xbc86052a),
0xfba31a97: ('vector2f_0xfba31a97', _decode_vector2f_0xfba31a97),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DistanceFog.py | 0.58166 | 0.376996 | DistanceFog.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.FOVInterpolationMethod import FOVInterpolationMethod
from retro_data_structures.properties.dkc_returns.archetypes.MotionInterpolationMethod import MotionInterpolationMethod
from retro_data_structures.properties.dkc_returns.archetypes.OrientationInterpolationMethod import OrientationInterpolationMethod
@dataclasses.dataclass()
class CustomInterpolation(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_camera_interpolation: int = dataclasses.field(default=3)
distance: float = dataclasses.field(default=100.0)
angle: float = dataclasses.field(default=135.0)
motion_interpolation: MotionInterpolationMethod = dataclasses.field(default_factory=MotionInterpolationMethod)
orientation_interpolation: OrientationInterpolationMethod = dataclasses.field(default_factory=OrientationInterpolationMethod)
fov_interpolation_method: FOVInterpolationMethod = dataclasses.field(default_factory=FOVInterpolationMethod)
@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 'CSTI'
@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'g\xa9\x84\xcb') # 0x67a984cb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_camera_interpolation))
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'8*\x19s') # 0x382a1973
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.angle))
data.write(b'\x843^q') # 0x84335e71
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_interpolation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\xf8\xd3\x19') # 0x1df8d319
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_interpolation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'1\xfa\xf0$') # 0x31faf024
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_interpolation_method.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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_camera_interpolation=data['flags_camera_interpolation'],
distance=data['distance'],
angle=data['angle'],
motion_interpolation=MotionInterpolationMethod.from_json(data['motion_interpolation']),
orientation_interpolation=OrientationInterpolationMethod.from_json(data['orientation_interpolation']),
fov_interpolation_method=FOVInterpolationMethod.from_json(data['fov_interpolation_method']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_camera_interpolation': self.flags_camera_interpolation,
'distance': self.distance,
'angle': self.angle,
'motion_interpolation': self.motion_interpolation.to_json(),
'orientation_interpolation': self.orientation_interpolation.to_json(),
'fov_interpolation_method': self.fov_interpolation_method.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_camera_interpolation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_motion_interpolation(data: typing.BinaryIO, property_size: int):
return MotionInterpolationMethod.from_stream(data, property_size)
def _decode_orientation_interpolation(data: typing.BinaryIO, property_size: int):
return OrientationInterpolationMethod.from_stream(data, property_size)
def _decode_fov_interpolation_method(data: typing.BinaryIO, property_size: int):
return FOVInterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x67a984cb: ('flags_camera_interpolation', _decode_flags_camera_interpolation),
0xc3bf43be: ('distance', _decode_distance),
0x382a1973: ('angle', _decode_angle),
0x84335e71: ('motion_interpolation', _decode_motion_interpolation),
0x1df8d319: ('orientation_interpolation', _decode_orientation_interpolation),
0x31faf024: ('fov_interpolation_method', _decode_fov_interpolation_method),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CustomInterpolation.py | 0.627837 | 0.377024 | CustomInterpolation.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 CameraBlurKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
blur_type: int = dataclasses.field(default=0)
blur_radius: float = dataclasses.field(default=0.0)
which_filter_group: int = dataclasses.field(default=0)
interpolate_in_time: float = dataclasses.field(default=0.0)
interpolate_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 'BLUR'
@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'\xe95\x91H') # 0xe9359148
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blur_type))
data.write(b'on\xb1\xf4') # 0x6f6eb1f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.blur_radius))
data.write(b'?\xdcK.') # 0x3fdc4b2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_filter_group))
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))
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']),
blur_type=data['blur_type'],
blur_radius=data['blur_radius'],
which_filter_group=data['which_filter_group'],
interpolate_in_time=data['interpolate_in_time'],
interpolate_out_time=data['interpolate_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'blur_type': self.blur_type,
'blur_radius': self.blur_radius,
'which_filter_group': self.which_filter_group,
'interpolate_in_time': self.interpolate_in_time,
'interpolate_out_time': self.interpolate_out_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_blur_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_blur_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', 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_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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe9359148: ('blur_type', _decode_blur_type),
0x6f6eb1f4: ('blur_radius', _decode_blur_radius),
0x3fdc4b2e: ('which_filter_group', _decode_which_filter_group),
0xabd41a36: ('interpolate_in_time', _decode_interpolate_in_time),
0x3eaf78fe: ('interpolate_out_time', _decode_interpolate_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CameraBlurKeyframe.py | 0.626581 | 0.326271 | CameraBlurKeyframe.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
@dataclasses.dataclass()
class DamageableTrigger(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)
only_take_damage_from_inhabitants: 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 'DTRG'
@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'\xce,\xf5\x10') # 0xce2cf510
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.only_take_damage_from_inhabitants))
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']),
only_take_damage_from_inhabitants=data['only_take_damage_from_inhabitants'],
)
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(),
'only_take_damage_from_inhabitants': self.only_take_damage_from_inhabitants,
}
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_only_take_damage_from_inhabitants(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),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x6652bdd7: ('invulnerable', _decode_invulnerable),
0x8b9d2123: ('damage_originator', _decode_damage_originator),
0xce2cf510: ('only_take_damage_from_inhabitants', _decode_only_take_damage_from_inhabitants),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/DamageableTrigger.py | 0.628635 | 0.373676 | DamageableTrigger.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.SavedStateID import SavedStateID
@dataclasses.dataclass()
class MemoryRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
object_id: SavedStateID = dataclasses.field(default_factory=SavedStateID)
one_shot: bool = dataclasses.field(default=False)
delayed_action: 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 'MRLY'
@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'\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'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
data.write(b'\xa9\x05\xcc\xf0') # 0xa905ccf0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.delayed_action))
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']),
one_shot=data['one_shot'],
delayed_action=data['delayed_action'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'object_id': self.object_id.to_json(),
'one_shot': self.one_shot,
'delayed_action': self.delayed_action,
}
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_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delayed_action(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),
0x16d9a75d: ('object_id', _decode_object_id),
0xead7b7bb: ('one_shot', _decode_one_shot),
0xa905ccf0: ('delayed_action', _decode_delayed_action),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MemoryRelay.py | 0.607197 | 0.335351 | MemoryRelay.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 ReviewControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
review_stage: enums.ReviewStage = dataclasses.field(default=enums.ReviewStage.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 'RCTL'
@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'\xb9l\n\xbe') # 0xb96c0abe
data.write(b'\x00\x04') # size
self.review_stage.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']),
review_stage=enums.ReviewStage.from_json(data['review_stage']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'review_stage': self.review_stage.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_review_stage(data: typing.BinaryIO, property_size: int):
return enums.ReviewStage.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb96c0abe: ('review_stage', _decode_review_stage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ReviewControl.py | 0.622345 | 0.350227 | ReviewControl.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.ScaleSplines import ScaleSplines
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 PlayerToken(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0xa9eb0fc8: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x0b30ecae: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x7ca5b474: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0xf9786405: int = dataclasses.field(default=0)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
scale_controls: ScaleSplines = dataclasses.field(default_factory=ScaleSplines)
scale_splines: ScaleSplines = dataclasses.field(default_factory=ScaleSplines)
@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 'PTOK'
@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'\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'\xa9\xeb\x0f\xc8') # 0xa9eb0fc8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xa9eb0fc8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0b0\xec\xae') # 0xb30ecae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x0b30ecae.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'|\xa5\xb4t') # 0x7ca5b474
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7ca5b474.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9xd\x05') # 0xf9786405
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xf9786405))
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'/~\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'h\x0e\x96\xea') # 0x680e96ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scale_splines.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']),
model=data['model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
unknown_0xa9eb0fc8=AnimationParameters.from_json(data['unknown_0xa9eb0fc8']),
unknown_0x0b30ecae=AnimationParameters.from_json(data['unknown_0x0b30ecae']),
unknown_0x7ca5b474=AnimationParameters.from_json(data['unknown_0x7ca5b474']),
unknown_0xf9786405=data['unknown_0xf9786405'],
actor_information=ActorParameters.from_json(data['actor_information']),
scale_controls=ScaleSplines.from_json(data['scale_controls']),
scale_splines=ScaleSplines.from_json(data['scale_splines']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'model': self.model,
'character_animation_information': self.character_animation_information.to_json(),
'unknown_0xa9eb0fc8': self.unknown_0xa9eb0fc8.to_json(),
'unknown_0x0b30ecae': self.unknown_0x0b30ecae.to_json(),
'unknown_0x7ca5b474': self.unknown_0x7ca5b474.to_json(),
'unknown_0xf9786405': self.unknown_0xf9786405,
'actor_information': self.actor_information.to_json(),
'scale_controls': self.scale_controls.to_json(),
'scale_splines': self.scale_splines.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
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_unknown_0xa9eb0fc8(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x0b30ecae(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x7ca5b474(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0xf9786405(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_scale_controls(data: typing.BinaryIO, property_size: int):
return ScaleSplines.from_stream(data, property_size)
def _decode_scale_splines(data: typing.BinaryIO, property_size: int):
return ScaleSplines.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),
0xc27ffa8f: ('model', _decode_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xa9eb0fc8: ('unknown_0xa9eb0fc8', _decode_unknown_0xa9eb0fc8),
0xb30ecae: ('unknown_0x0b30ecae', _decode_unknown_0x0b30ecae),
0x7ca5b474: ('unknown_0x7ca5b474', _decode_unknown_0x7ca5b474),
0xf9786405: ('unknown_0xf9786405', _decode_unknown_0xf9786405),
0x7e397fed: ('actor_information', _decode_actor_information),
0x2f7ec0a2: ('scale_controls', _decode_scale_controls),
0x680e96ea: ('scale_splines', _decode_scale_splines),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PlayerToken.py | 0.551332 | 0.32146 | PlayerToken.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.AreaPathStructA import AreaPathStructA
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class AreaPath(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
cmdl: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
type: enums.Type = dataclasses.field(default=enums.Type.Unknown1)
padlock_path: bool = dataclasses.field(default=False)
unknown_0xd626b1d8: bool = dataclasses.field(default=True)
unknown_0x45bb081b: bool = dataclasses.field(default=False)
draw_time: float = dataclasses.field(default=0.5)
walk_time: float = dataclasses.field(default=0.5)
path: Spline = dataclasses.field(default_factory=Spline)
area_path_struct_a: AreaPathStructA = dataclasses.field(default_factory=AreaPathStructA)
reveal_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
reveal_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, 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 'ARPA'
@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\x0f') # 15 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\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'\xdeW\t\xd9') # 0xde5709d9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cmdl))
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'GK\xcc\xe3') # 0x474bcce3
data.write(b'\x00\x04') # size
self.type.to_stream(data)
data.write(b'ua\xf8\xf7') # 0x7561f8f7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.padlock_path))
data.write(b'\xd6&\xb1\xd8') # 0xd626b1d8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd626b1d8))
data.write(b'E\xbb\x08\x1b') # 0x45bb081b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x45bb081b))
data.write(b'\x9d\xc4;\x9c') # 0x9dc43b9c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.draw_time))
data.write(b'\x19\x89\xe2\xe5') # 0x1989e2e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.walk_time))
data.write(b'\xfa\x0e\xed\x84') # 0xfa0eed84
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xfa{\x19') # 0x91fa7b19
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.area_path_struct_a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b2\xdcP') # 0x1b32dc50
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.reveal_effect))
data.write(b'|d,\x9c') # 0x7c642c9c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.reveal_sound))
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']),
model=data['model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
cmdl=data['cmdl'],
actor_information=ActorParameters.from_json(data['actor_information']),
type=enums.Type.from_json(data['type']),
padlock_path=data['padlock_path'],
unknown_0xd626b1d8=data['unknown_0xd626b1d8'],
unknown_0x45bb081b=data['unknown_0x45bb081b'],
draw_time=data['draw_time'],
walk_time=data['walk_time'],
path=Spline.from_json(data['path']),
area_path_struct_a=AreaPathStructA.from_json(data['area_path_struct_a']),
reveal_effect=data['reveal_effect'],
reveal_sound=data['reveal_sound'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'model': self.model,
'character_animation_information': self.character_animation_information.to_json(),
'cmdl': self.cmdl,
'actor_information': self.actor_information.to_json(),
'type': self.type.to_json(),
'padlock_path': self.padlock_path,
'unknown_0xd626b1d8': self.unknown_0xd626b1d8,
'unknown_0x45bb081b': self.unknown_0x45bb081b,
'draw_time': self.draw_time,
'walk_time': self.walk_time,
'path': self.path.to_json(),
'area_path_struct_a': self.area_path_struct_a.to_json(),
'reveal_effect': self.reveal_effect,
'reveal_sound': self.reveal_sound,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
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_cmdl(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_type(data: typing.BinaryIO, property_size: int):
return enums.Type.from_stream(data)
def _decode_padlock_path(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xd626b1d8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x45bb081b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_draw_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_walk_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_path(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_area_path_struct_a(data: typing.BinaryIO, property_size: int):
return AreaPathStructA.from_stream(data, property_size)
def _decode_reveal_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_reveal_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc27ffa8f: ('model', _decode_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xde5709d9: ('cmdl', _decode_cmdl),
0x7e397fed: ('actor_information', _decode_actor_information),
0x474bcce3: ('type', _decode_type),
0x7561f8f7: ('padlock_path', _decode_padlock_path),
0xd626b1d8: ('unknown_0xd626b1d8', _decode_unknown_0xd626b1d8),
0x45bb081b: ('unknown_0x45bb081b', _decode_unknown_0x45bb081b),
0x9dc43b9c: ('draw_time', _decode_draw_time),
0x1989e2e5: ('walk_time', _decode_walk_time),
0xfa0eed84: ('path', _decode_path),
0x91fa7b19: ('area_path_struct_a', _decode_area_path_struct_a),
0x1b32dc50: ('reveal_effect', _decode_reveal_effect),
0x7c642c9c: ('reveal_sound', _decode_reveal_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AreaPath.py | 0.560253 | 0.249196 | AreaPath.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.AnimGridModifierData import AnimGridModifierData
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.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct8 import UnknownStruct8
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.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 Actor(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))
mass: float = dataclasses.field(default=1.0)
gravity: float = dataclasses.field(default=0.0)
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)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
is_loop: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
is_solid: bool = dataclasses.field(default=True)
is_camera_through: bool = dataclasses.field(default=False)
unknown_0x87613768: bool = dataclasses.field(default=False)
unknown_0xe2ddc4c1: str = dataclasses.field(default='')
render_texture_set: int = dataclasses.field(default=0)
render_push: float = dataclasses.field(default=0.0)
render_first_sorted: bool = dataclasses.field(default=False)
unknown_0x0d8098bf: bool = dataclasses.field(default=False)
unknown_0x4ddc1327: bool = dataclasses.field(default=False)
render_in_foreground: bool = dataclasses.field(default=False)
ignore_fog: bool = dataclasses.field(default=False)
scale_animation: bool = dataclasses.field(default=True)
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)
unknown_0xc1b9c601: bool = dataclasses.field(default=False)
unknown_0x27e50799: bool = dataclasses.field(default=False)
animation_offset: float = dataclasses.field(default=0.0)
animation_time_scale: float = dataclasses.field(default=1.0)
unknown_0xa38a84c2: bool = dataclasses.field(default=False)
unknown_struct8: UnknownStruct8 = dataclasses.field(default_factory=UnknownStruct8)
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 'ACTR'
@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$') # 36 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'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
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'\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'\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'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'xY\xb5 ') # 0x7859b520
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_camera_through))
data.write(b'\x87a7h') # 0x87613768
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x87613768))
data.write(b'\xe2\xdd\xc4\xc1') # 0xe2ddc4c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xe2ddc4c1.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'2\xfa\xb9~') # 0x32fab97e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_texture_set))
data.write(b'\xaaq\x962') # 0xaa719632
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push))
data.write(b'GC)O') # 0x4743294f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_first_sorted))
data.write(b'\r\x80\x98\xbf') # 0xd8098bf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x0d8098bf))
data.write(b"M\xdc\x13'") # 0x4ddc1327
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4ddc1327))
data.write(b'\xa6\xaa\x06\xd5') # 0xa6aa06d5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_in_foreground))
data.write(b's\xe7\xbf\xe9') # 0x73e7bfe9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_fog))
data.write(b'&\x1e\x92\xa4') # 0x261e92a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scale_animation))
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'\xc1\xb9\xc6\x01') # 0xc1b9c601
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc1b9c601))
data.write(b"'\xe5\x07\x99") # 0x27e50799
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x27e50799))
data.write(b'"\xe0F\xba') # 0x22e046ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.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'\xa3\x8a\x84\xc2') # 0xa38a84c2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa38a84c2))
data.write(b'lu\xe2\xea') # 0x6c75e2ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct8.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']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
mass=data['mass'],
gravity=data['gravity'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
model=data['model'],
collision_model=data['collision_model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
is_loop=data['is_loop'],
immovable=data['immovable'],
is_solid=data['is_solid'],
is_camera_through=data['is_camera_through'],
unknown_0x87613768=data['unknown_0x87613768'],
unknown_0xe2ddc4c1=data['unknown_0xe2ddc4c1'],
render_texture_set=data['render_texture_set'],
render_push=data['render_push'],
render_first_sorted=data['render_first_sorted'],
unknown_0x0d8098bf=data['unknown_0x0d8098bf'],
unknown_0x4ddc1327=data['unknown_0x4ddc1327'],
render_in_foreground=data['render_in_foreground'],
ignore_fog=data['ignore_fog'],
scale_animation=data['scale_animation'],
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']),
unknown_0xc1b9c601=data['unknown_0xc1b9c601'],
unknown_0x27e50799=data['unknown_0x27e50799'],
animation_offset=data['animation_offset'],
animation_time_scale=data['animation_time_scale'],
unknown_0xa38a84c2=data['unknown_0xa38a84c2'],
unknown_struct8=UnknownStruct8.from_json(data['unknown_struct8']),
anim_grid=AnimGridModifierData.from_json(data['anim_grid']),
)
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(),
'mass': self.mass,
'gravity': self.gravity,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'character_animation_information': self.character_animation_information.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'is_loop': self.is_loop,
'immovable': self.immovable,
'is_solid': self.is_solid,
'is_camera_through': self.is_camera_through,
'unknown_0x87613768': self.unknown_0x87613768,
'unknown_0xe2ddc4c1': self.unknown_0xe2ddc4c1,
'render_texture_set': self.render_texture_set,
'render_push': self.render_push,
'render_first_sorted': self.render_first_sorted,
'unknown_0x0d8098bf': self.unknown_0x0d8098bf,
'unknown_0x4ddc1327': self.unknown_0x4ddc1327,
'render_in_foreground': self.render_in_foreground,
'ignore_fog': self.ignore_fog,
'scale_animation': self.scale_animation,
'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(),
'unknown_0xc1b9c601': self.unknown_0xc1b9c601,
'unknown_0x27e50799': self.unknown_0x27e50799,
'animation_offset': self.animation_offset,
'animation_time_scale': self.animation_time_scale,
'unknown_0xa38a84c2': self.unknown_0xa38a84c2,
'unknown_struct8': self.unknown_struct8.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_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_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_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_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_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_is_loop(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]
def _decode_is_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_camera_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x87613768(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe2ddc4c1(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_render_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_render_push(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_render_first_sorted(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x0d8098bf(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4ddc1327(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_in_foreground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_fog(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
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_unknown_0xc1b9c601(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x27e50799(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_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_0xa38a84c2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct8(data: typing.BinaryIO, property_size: int):
return UnknownStruct8.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),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x75dbb375: ('mass', _decode_mass),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x1e32523e: ('immovable', _decode_immovable),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x7859b520: ('is_camera_through', _decode_is_camera_through),
0x87613768: ('unknown_0x87613768', _decode_unknown_0x87613768),
0xe2ddc4c1: ('unknown_0xe2ddc4c1', _decode_unknown_0xe2ddc4c1),
0x32fab97e: ('render_texture_set', _decode_render_texture_set),
0xaa719632: ('render_push', _decode_render_push),
0x4743294f: ('render_first_sorted', _decode_render_first_sorted),
0xd8098bf: ('unknown_0x0d8098bf', _decode_unknown_0x0d8098bf),
0x4ddc1327: ('unknown_0x4ddc1327', _decode_unknown_0x4ddc1327),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
0x73e7bfe9: ('ignore_fog', _decode_ignore_fog),
0x261e92a4: ('scale_animation', _decode_scale_animation),
0xb530d7de: ('use_mod_inca', _decode_use_mod_inca),
0xf8df6cd2: ('mod_inca_color', _decode_mod_inca_color),
0xc23011d9: ('mod_inca_amount', _decode_mod_inca_amount),
0xc1b9c601: ('unknown_0xc1b9c601', _decode_unknown_0xc1b9c601),
0x27e50799: ('unknown_0x27e50799', _decode_unknown_0x27e50799),
0x22e046ba: ('animation_offset', _decode_animation_offset),
0xbe513e2b: ('animation_time_scale', _decode_animation_time_scale),
0xa38a84c2: ('unknown_0xa38a84c2', _decode_unknown_0xa38a84c2),
0x6c75e2ea: ('unknown_struct8', _decode_unknown_struct8),
0x68fd49ae: ('anim_grid', _decode_anim_grid),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Actor.py | 0.672869 | 0.226612 | Actor.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 BloomVolume(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 'BLMV'
@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'8\x01\xa5k') # 0x3801a56b
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),
0x3801a56b: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BloomVolume.py | 0.618665 | 0.356055 | BloomVolume.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.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.PlayerAlternateSkin import PlayerAlternateSkin
from retro_data_structures.properties.dkc_returns.archetypes.PlayerType import PlayerType
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct8 import UnknownStruct8
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 PlayerActor(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))
mass: float = dataclasses.field(default=1.0)
gravity: float = dataclasses.field(default=0.0)
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)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
is_loop: bool = dataclasses.field(default=True)
unknown_0x87613768: bool = dataclasses.field(default=False)
unknown_0xe2ddc4c1: str = dataclasses.field(default='')
is_camera_through: bool = dataclasses.field(default=False)
render_texture_set: int = dataclasses.field(default=0)
render_push: float = dataclasses.field(default=0.0)
render_first_sorted: bool = dataclasses.field(default=False)
render_in_foreground: bool = dataclasses.field(default=False)
ignore_fog: bool = dataclasses.field(default=False)
scale_animation: bool = dataclasses.field(default=True)
unknown_0xc1b9c601: bool = dataclasses.field(default=False)
unknown_0x27e50799: bool = dataclasses.field(default=False)
animation_offset: float = dataclasses.field(default=0.0)
animation_time_scale: float = dataclasses.field(default=1.0)
unknown_struct6_0xe1bcef23: PlayerType = dataclasses.field(default_factory=PlayerType)
unknown_struct6_0x963e45f6: PlayerType = dataclasses.field(default_factory=PlayerType)
unknown_struct8: UnknownStruct8 = dataclasses.field(default_factory=UnknownStruct8)
alternate_skins: PlayerAlternateSkin = dataclasses.field(default_factory=PlayerAlternateSkin)
@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 'PLAC'
@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\x1d') # 29 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'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
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'\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'\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'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b'\x87a7h') # 0x87613768
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x87613768))
data.write(b'\xe2\xdd\xc4\xc1') # 0xe2ddc4c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xe2ddc4c1.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'xY\xb5 ') # 0x7859b520
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_camera_through))
data.write(b'2\xfa\xb9~') # 0x32fab97e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_texture_set))
data.write(b'\xaaq\x962') # 0xaa719632
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.render_push))
data.write(b'GC)O') # 0x4743294f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_first_sorted))
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's\xe7\xbf\xe9') # 0x73e7bfe9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_fog))
data.write(b'&\x1e\x92\xa4') # 0x261e92a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scale_animation))
data.write(b'\xc1\xb9\xc6\x01') # 0xc1b9c601
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc1b9c601))
data.write(b"'\xe5\x07\x99") # 0x27e50799
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x27e50799))
data.write(b'"\xe0F\xba') # 0x22e046ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.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'\xe1\xbc\xef#') # 0xe1bcef23
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct6_0xe1bcef23.to_stream(data, default_override={'character_type': enums.CharacterType.Unknown6})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x96>E\xf6') # 0x963e45f6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct6_0x963e45f6.to_stream(data, default_override={'character_type': enums.CharacterType.Unknown6})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'lu\xe2\xea') # 0x6c75e2ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct8.to_stream(data)
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)
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']),
mass=data['mass'],
gravity=data['gravity'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
model=data['model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
is_loop=data['is_loop'],
unknown_0x87613768=data['unknown_0x87613768'],
unknown_0xe2ddc4c1=data['unknown_0xe2ddc4c1'],
is_camera_through=data['is_camera_through'],
render_texture_set=data['render_texture_set'],
render_push=data['render_push'],
render_first_sorted=data['render_first_sorted'],
render_in_foreground=data['render_in_foreground'],
ignore_fog=data['ignore_fog'],
scale_animation=data['scale_animation'],
unknown_0xc1b9c601=data['unknown_0xc1b9c601'],
unknown_0x27e50799=data['unknown_0x27e50799'],
animation_offset=data['animation_offset'],
animation_time_scale=data['animation_time_scale'],
unknown_struct6_0xe1bcef23=PlayerType.from_json(data['unknown_struct6_0xe1bcef23']),
unknown_struct6_0x963e45f6=PlayerType.from_json(data['unknown_struct6_0x963e45f6']),
unknown_struct8=UnknownStruct8.from_json(data['unknown_struct8']),
alternate_skins=PlayerAlternateSkin.from_json(data['alternate_skins']),
)
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(),
'mass': self.mass,
'gravity': self.gravity,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'model': self.model,
'character_animation_information': self.character_animation_information.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'is_loop': self.is_loop,
'unknown_0x87613768': self.unknown_0x87613768,
'unknown_0xe2ddc4c1': self.unknown_0xe2ddc4c1,
'is_camera_through': self.is_camera_through,
'render_texture_set': self.render_texture_set,
'render_push': self.render_push,
'render_first_sorted': self.render_first_sorted,
'render_in_foreground': self.render_in_foreground,
'ignore_fog': self.ignore_fog,
'scale_animation': self.scale_animation,
'unknown_0xc1b9c601': self.unknown_0xc1b9c601,
'unknown_0x27e50799': self.unknown_0x27e50799,
'animation_offset': self.animation_offset,
'animation_time_scale': self.animation_time_scale,
'unknown_struct6_0xe1bcef23': self.unknown_struct6_0xe1bcef23.to_json(),
'unknown_struct6_0x963e45f6': self.unknown_struct6_0x963e45f6.to_json(),
'unknown_struct8': self.unknown_struct8.to_json(),
'alternate_skins': self.alternate_skins.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_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_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_character_animation_information(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_is_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x87613768(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe2ddc4c1(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_is_camera_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_render_push(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_render_first_sorted(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_ignore_fog(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xc1b9c601(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x27e50799(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_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_struct6_0xe1bcef23(data: typing.BinaryIO, property_size: int):
return PlayerType.from_stream(data, property_size, default_override={'character_type': enums.CharacterType.Unknown6})
def _decode_unknown_struct6_0x963e45f6(data: typing.BinaryIO, property_size: int):
return PlayerType.from_stream(data, property_size, default_override={'character_type': enums.CharacterType.Unknown6})
def _decode_unknown_struct8(data: typing.BinaryIO, property_size: int):
return UnknownStruct8.from_stream(data, property_size)
def _decode_alternate_skins(data: typing.BinaryIO, property_size: int):
return PlayerAlternateSkin.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),
0x75dbb375: ('mass', _decode_mass),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xc27ffa8f: ('model', _decode_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x87613768: ('unknown_0x87613768', _decode_unknown_0x87613768),
0xe2ddc4c1: ('unknown_0xe2ddc4c1', _decode_unknown_0xe2ddc4c1),
0x7859b520: ('is_camera_through', _decode_is_camera_through),
0x32fab97e: ('render_texture_set', _decode_render_texture_set),
0xaa719632: ('render_push', _decode_render_push),
0x4743294f: ('render_first_sorted', _decode_render_first_sorted),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
0x73e7bfe9: ('ignore_fog', _decode_ignore_fog),
0x261e92a4: ('scale_animation', _decode_scale_animation),
0xc1b9c601: ('unknown_0xc1b9c601', _decode_unknown_0xc1b9c601),
0x27e50799: ('unknown_0x27e50799', _decode_unknown_0x27e50799),
0x22e046ba: ('animation_offset', _decode_animation_offset),
0xbe513e2b: ('animation_time_scale', _decode_animation_time_scale),
0xe1bcef23: ('unknown_struct6_0xe1bcef23', _decode_unknown_struct6_0xe1bcef23),
0x963e45f6: ('unknown_struct6_0x963e45f6', _decode_unknown_struct6_0x963e45f6),
0x6c75e2ea: ('unknown_struct8', _decode_unknown_struct8),
0x2e9827ad: ('alternate_skins', _decode_alternate_skins),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PlayerActor.py | 0.634543 | 0.228974 | PlayerActor.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.UnknownStruct262 import UnknownStruct262
@dataclasses.dataclass()
class RobotChickenFlyer(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_struct262: UnknownStruct262 = dataclasses.field(default_factory=UnknownStruct262)
@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 'RCKF'
@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';\xff\xc0\xd1') # 0x3bffc0d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct262.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_struct262=UnknownStruct262.from_json(data['unknown_struct262']),
)
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_struct262': self.unknown_struct262.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_struct262(data: typing.BinaryIO, property_size: int):
return UnknownStruct262.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),
0x3bffc0d1: ('unknown_struct262', _decode_unknown_struct262),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RobotChickenFlyer.py | 0.641759 | 0.332744 | RobotChickenFlyer.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.archetypes.LightParameters import LightParameters
from retro_data_structures.properties.dkc_returns.archetypes.SplineType import SplineType
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class Effect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART', 'SPSC', 'SWHC']}, default=default_asset_id)
auto_start: bool = dataclasses.field(default=True)
unknown_0x3df5a489: bool = dataclasses.field(default=False)
unknown_0x08349bd6: bool = dataclasses.field(default=False)
render_in_foreground: bool = dataclasses.field(default=False)
unknown_0x6714021c: bool = dataclasses.field(default=True)
unknown_0xbe931927: bool = dataclasses.field(default=False)
unknown_0xe448aa81: bool = dataclasses.field(default=False)
unknown_0x3613bc90: bool = dataclasses.field(default=False)
render_override: enums.RenderOverride = dataclasses.field(default=enums.RenderOverride.Unknown3)
lighting: LightParameters = dataclasses.field(default_factory=LightParameters)
unknown_0xacc1a0aa: bool = dataclasses.field(default=False)
motion_spline_path_loops: bool = dataclasses.field(default=False)
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
motion_spline_duration: float = dataclasses.field(default=10.0)
unknown_0x73e63382: bool = dataclasses.field(default=False)
unknown_0x608ecac5: bool = dataclasses.field(default=False)
not_moving: bool = dataclasses.field(default=False)
depth_bias: float = dataclasses.field(default=0.0)
unknown_0x70073577: int = dataclasses.field(default=3)
unknown_0xb0f5e028: 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 'EFCT'
@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\x17') # 23 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'\nG\x9do') # 0xa479d6f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle_effect))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'=\xf5\xa4\x89') # 0x3df5a489
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3df5a489))
data.write(b'\x084\x9b\xd6') # 0x8349bd6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x08349bd6))
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'g\x14\x02\x1c') # 0x6714021c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x6714021c))
data.write(b"\xbe\x93\x19'") # 0xbe931927
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbe931927))
data.write(b'\xe4H\xaa\x81') # 0xe448aa81
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe448aa81))
data.write(b'6\x13\xbc\x90') # 0x3613bc90
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3613bc90))
data.write(b'-\xefp]') # 0x2def705d
data.write(b'\x00\x04') # size
self.render_override.to_stream(data)
data.write(b'\xb0(\xdb\x0e') # 0xb028db0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xac\xc1\xa0\xaa') # 0xacc1a0aa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xacc1a0aa))
data.write(b'=t\x06\xaf') # 0x3d7406af
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.motion_spline_path_loops))
data.write(b'I=j-') # 0x493d6a2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x1e/V') # 0xfd1e2f56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.motion_spline_duration))
data.write(b's\xe63\x82') # 0x73e63382
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x73e63382))
data.write(b'`\x8e\xca\xc5') # 0x608ecac5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x608ecac5))
data.write(b'R{\x89\xd3') # 0x527b89d3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.not_moving))
data.write(b']<r9') # 0x5d3c7239
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.depth_bias))
data.write(b'p\x075w') # 0x70073577
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x70073577))
data.write(b'\xb0\xf5\xe0(') # 0xb0f5e028
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb0f5e028))
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']),
particle_effect=data['particle_effect'],
auto_start=data['auto_start'],
unknown_0x3df5a489=data['unknown_0x3df5a489'],
unknown_0x08349bd6=data['unknown_0x08349bd6'],
render_in_foreground=data['render_in_foreground'],
unknown_0x6714021c=data['unknown_0x6714021c'],
unknown_0xbe931927=data['unknown_0xbe931927'],
unknown_0xe448aa81=data['unknown_0xe448aa81'],
unknown_0x3613bc90=data['unknown_0x3613bc90'],
render_override=enums.RenderOverride.from_json(data['render_override']),
lighting=LightParameters.from_json(data['lighting']),
unknown_0xacc1a0aa=data['unknown_0xacc1a0aa'],
motion_spline_path_loops=data['motion_spline_path_loops'],
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
motion_spline_duration=data['motion_spline_duration'],
unknown_0x73e63382=data['unknown_0x73e63382'],
unknown_0x608ecac5=data['unknown_0x608ecac5'],
not_moving=data['not_moving'],
depth_bias=data['depth_bias'],
unknown_0x70073577=data['unknown_0x70073577'],
unknown_0xb0f5e028=data['unknown_0xb0f5e028'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'particle_effect': self.particle_effect,
'auto_start': self.auto_start,
'unknown_0x3df5a489': self.unknown_0x3df5a489,
'unknown_0x08349bd6': self.unknown_0x08349bd6,
'render_in_foreground': self.render_in_foreground,
'unknown_0x6714021c': self.unknown_0x6714021c,
'unknown_0xbe931927': self.unknown_0xbe931927,
'unknown_0xe448aa81': self.unknown_0xe448aa81,
'unknown_0x3613bc90': self.unknown_0x3613bc90,
'render_override': self.render_override.to_json(),
'lighting': self.lighting.to_json(),
'unknown_0xacc1a0aa': self.unknown_0xacc1a0aa,
'motion_spline_path_loops': self.motion_spline_path_loops,
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'motion_spline_duration': self.motion_spline_duration,
'unknown_0x73e63382': self.unknown_0x73e63382,
'unknown_0x608ecac5': self.unknown_0x608ecac5,
'not_moving': self.not_moving,
'depth_bias': self.depth_bias,
'unknown_0x70073577': self.unknown_0x70073577,
'unknown_0xb0f5e028': self.unknown_0xb0f5e028,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x3df5a489(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x08349bd6(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_0x6714021c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbe931927(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe448aa81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x3613bc90(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_override(data: typing.BinaryIO, property_size: int):
return enums.RenderOverride.from_stream(data)
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightParameters.from_stream(data, property_size)
def _decode_unknown_0xacc1a0aa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_path_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_motion_spline_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x73e63382(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x608ecac5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_not_moving(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_bias(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x70073577(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xb0f5e028(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),
0xa479d6f: ('particle_effect', _decode_particle_effect),
0x3217dff8: ('auto_start', _decode_auto_start),
0x3df5a489: ('unknown_0x3df5a489', _decode_unknown_0x3df5a489),
0x8349bd6: ('unknown_0x08349bd6', _decode_unknown_0x08349bd6),
0xa6aa06d5: ('render_in_foreground', _decode_render_in_foreground),
0x6714021c: ('unknown_0x6714021c', _decode_unknown_0x6714021c),
0xbe931927: ('unknown_0xbe931927', _decode_unknown_0xbe931927),
0xe448aa81: ('unknown_0xe448aa81', _decode_unknown_0xe448aa81),
0x3613bc90: ('unknown_0x3613bc90', _decode_unknown_0x3613bc90),
0x2def705d: ('render_override', _decode_render_override),
0xb028db0e: ('lighting', _decode_lighting),
0xacc1a0aa: ('unknown_0xacc1a0aa', _decode_unknown_0xacc1a0aa),
0x3d7406af: ('motion_spline_path_loops', _decode_motion_spline_path_loops),
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
0x73e63382: ('unknown_0x73e63382', _decode_unknown_0x73e63382),
0x608ecac5: ('unknown_0x608ecac5', _decode_unknown_0x608ecac5),
0x527b89d3: ('not_moving', _decode_not_moving),
0x5d3c7239: ('depth_bias', _decode_depth_bias),
0x70073577: ('unknown_0x70073577', _decode_unknown_0x70073577),
0xb0f5e028: ('unknown_0xb0f5e028', _decode_unknown_0xb0f5e028),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Effect.py | 0.565179 | 0.249242 | Effect.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.ActorMultiKeyframeData import ActorMultiKeyframeData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ActorMultiKeyFrame(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
mirrored: bool = dataclasses.field(default=False)
actor_multi_keyframe_data: ActorMultiKeyframeData = dataclasses.field(default_factory=ActorMultiKeyframeData)
@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 'AMKF'
@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'\x1f\xe4L:') # 0x1fe44c3a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.mirrored))
data.write(b'H\xb5\xb2\xa2') # 0x48b5b2a2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_multi_keyframe_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']),
mirrored=data['mirrored'],
actor_multi_keyframe_data=ActorMultiKeyframeData.from_json(data['actor_multi_keyframe_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'mirrored': self.mirrored,
'actor_multi_keyframe_data': self.actor_multi_keyframe_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_mirrored(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_actor_multi_keyframe_data(data: typing.BinaryIO, property_size: int):
return ActorMultiKeyframeData.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),
0x1fe44c3a: ('mirrored', _decode_mirrored),
0x48b5b2a2: ('actor_multi_keyframe_data', _decode_actor_multi_keyframe_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ActorMultiKeyFrame.py | 0.644784 | 0.32461 | ActorMultiKeyFrame.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 EnvFxDensityController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
density: float = dataclasses.field(default=0.5)
fade_speed: int = dataclasses.field(default=500)
@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 'FXDC'
@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'd\xe5\xfe\x9f') # 0x64e5fe9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.density))
data.write(b'e\xa8#\xb4') # 0x65a823b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fade_speed))
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']),
density=data['density'],
fade_speed=data['fade_speed'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'density': self.density,
'fade_speed': self.fade_speed,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_speed(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),
0x64e5fe9f: ('density', _decode_density),
0x65a823b4: ('fade_speed', _decode_fade_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/EnvFxDensityController.py | 0.664976 | 0.356587 | EnvFxDensityController.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.Color import Color
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class ColorModulate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
color_a: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
color_b: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
blend_mode: enums.Blend_Mode = dataclasses.field(default=enums.Blend_Mode.Unknown1)
time_a2_b: float = dataclasses.field(default=1.0)
time_b2_a: float = dataclasses.field(default=1.0)
do_reverse: bool = dataclasses.field(default=False)
reset_target_when_done: bool = dataclasses.field(default=False)
depth_compare: bool = dataclasses.field(default=True)
depth_update: bool = dataclasses.field(default=True)
depth_backwards: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
update_time: bool = dataclasses.field(default=True)
loop_forever: bool = dataclasses.field(default=False)
external_time: bool = dataclasses.field(default=False)
copy_model_color_to_color_a: bool = dataclasses.field(default=False)
write_depth_first: bool = dataclasses.field(default=False)
control_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 'CLRM'
@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\x12') # 18 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'\xd6\xa3\xd2o') # 0xd6a3d26f
data.write(b'\x00\x10') # size
self.color_a.to_stream(data)
data.write(b'P7\xa0\xc1') # 0x5037a0c1
data.write(b'\x00\x10') # size
self.color_b.to_stream(data)
data.write(b'\xffEuF') # 0xff457546
data.write(b'\x00\x04') # size
self.blend_mode.to_stream(data)
data.write(b'\x1a\xfa\\H') # 0x1afa5c48
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_a2_b))
data.write(b'\x12\xe1)\x05') # 0x12e12905
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_b2_a))
data.write(b'\xce\xc5$K') # 0xcec5244b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.do_reverse))
data.write(b'\x81\xfc\x97\x9c') # 0x81fc979c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reset_target_when_done))
data.write(b'\x94\xc0\x1b\x0c') # 0x94c01b0c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_compare))
data.write(b'\xae\xd2ZQ') # 0xaed25a51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_update))
data.write(b'5\xdcC\xd0') # 0x35dc43d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_backwards))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b':\x7fY\xf7') # 0x3a7f59f7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.update_time))
data.write(b'\x08\xbbs\xc5') # 0x8bb73c5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_forever))
data.write(b'~7\x9a\xe8') # 0x7e379ae8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.external_time))
data.write(b't\x08\x1e\x94') # 0x74081e94
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.copy_model_color_to_color_a))
data.write(b'\x9a0g@') # 0x9a306740
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.write_depth_first))
data.write(b'\x15V\x7f\xe7') # 0x15567fe7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
color_a=Color.from_json(data['color_a']),
color_b=Color.from_json(data['color_b']),
blend_mode=enums.Blend_Mode.from_json(data['blend_mode']),
time_a2_b=data['time_a2_b'],
time_b2_a=data['time_b2_a'],
do_reverse=data['do_reverse'],
reset_target_when_done=data['reset_target_when_done'],
depth_compare=data['depth_compare'],
depth_update=data['depth_update'],
depth_backwards=data['depth_backwards'],
auto_start=data['auto_start'],
update_time=data['update_time'],
loop_forever=data['loop_forever'],
external_time=data['external_time'],
copy_model_color_to_color_a=data['copy_model_color_to_color_a'],
write_depth_first=data['write_depth_first'],
control_spline=Spline.from_json(data['control_spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'color_a': self.color_a.to_json(),
'color_b': self.color_b.to_json(),
'blend_mode': self.blend_mode.to_json(),
'time_a2_b': self.time_a2_b,
'time_b2_a': self.time_b2_a,
'do_reverse': self.do_reverse,
'reset_target_when_done': self.reset_target_when_done,
'depth_compare': self.depth_compare,
'depth_update': self.depth_update,
'depth_backwards': self.depth_backwards,
'auto_start': self.auto_start,
'update_time': self.update_time,
'loop_forever': self.loop_forever,
'external_time': self.external_time,
'copy_model_color_to_color_a': self.copy_model_color_to_color_a,
'write_depth_first': self.write_depth_first,
'control_spline': self.control_spline.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_color_a(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_color_b(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.Blend_Mode.from_stream(data)
def _decode_time_a2_b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_b2_a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_do_reverse(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_reset_target_when_done(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_compare(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_update(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_backwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_update_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_forever(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_external_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_copy_model_color_to_color_a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_write_depth_first(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd6a3d26f: ('color_a', _decode_color_a),
0x5037a0c1: ('color_b', _decode_color_b),
0xff457546: ('blend_mode', _decode_blend_mode),
0x1afa5c48: ('time_a2_b', _decode_time_a2_b),
0x12e12905: ('time_b2_a', _decode_time_b2_a),
0xcec5244b: ('do_reverse', _decode_do_reverse),
0x81fc979c: ('reset_target_when_done', _decode_reset_target_when_done),
0x94c01b0c: ('depth_compare', _decode_depth_compare),
0xaed25a51: ('depth_update', _decode_depth_update),
0x35dc43d0: ('depth_backwards', _decode_depth_backwards),
0x3217dff8: ('auto_start', _decode_auto_start),
0x3a7f59f7: ('update_time', _decode_update_time),
0x8bb73c5: ('loop_forever', _decode_loop_forever),
0x7e379ae8: ('external_time', _decode_external_time),
0x74081e94: ('copy_model_color_to_color_a', _decode_copy_model_color_to_color_a),
0x9a306740: ('write_depth_first', _decode_write_depth_first),
0x15567fe7: ('control_spline', _decode_control_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/ColorModulate.py | 0.5794 | 0.341226 | ColorModulate.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.OceanBridgeData import OceanBridgeData
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class OceanBridge(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
ocean_bridge_data: OceanBridgeData = dataclasses.field(default_factory=OceanBridgeData)
@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 'OBRG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_OceanBridge.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'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
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'\xb3?\x8c\xe5') # 0xb33f8ce5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ocean_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']),
model=data['model'],
actor_information=ActorParameters.from_json(data['actor_information']),
ocean_bridge_data=OceanBridgeData.from_json(data['ocean_bridge_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'model': self.model,
'actor_information': self.actor_information.to_json(),
'ocean_bridge_data': self.ocean_bridge_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_model(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_ocean_bridge_data(data: typing.BinaryIO, property_size: int):
return OceanBridgeData.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),
0xc27ffa8f: ('model', _decode_model),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb33f8ce5: ('ocean_bridge_data', _decode_ocean_bridge_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/OceanBridge.py | 0.641198 | 0.304752 | OceanBridge.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.PlayerCommonData import PlayerCommonData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMountData import PlayerMountData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMountRiderList import PlayerMountRiderList
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.UnknownStruct297 import UnknownStruct297
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class VerticalRocketBarrel(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct: UnknownStruct = dataclasses.field(default_factory=UnknownStruct)
common: PlayerCommonData = dataclasses.field(default_factory=PlayerCommonData)
mount_data: PlayerMountData = dataclasses.field(default_factory=PlayerMountData)
rider_list_data: PlayerMountRiderList = dataclasses.field(default_factory=PlayerMountRiderList)
unknown_struct297: UnknownStruct297 = dataclasses.field(default_factory=UnknownStruct297)
@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 'VRBR'
@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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_radius': 0.5, 'collision_offset': Vector(x=0.0, y=0.0, z=-0.699999988079071)})
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'<8I\x8d') # 0x3c38498d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.common.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\x8e[\xd8') # 0x978e5bd8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mount_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7fh\x14\x11') # 0x7f681411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rider_list_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\xb5\xb7T') # 0x45b5b754
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct297.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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct=UnknownStruct.from_json(data['unknown_struct']),
common=PlayerCommonData.from_json(data['common']),
mount_data=PlayerMountData.from_json(data['mount_data']),
rider_list_data=PlayerMountRiderList.from_json(data['rider_list_data']),
unknown_struct297=UnknownStruct297.from_json(data['unknown_struct297']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct': self.unknown_struct.to_json(),
'common': self.common.to_json(),
'mount_data': self.mount_data.to_json(),
'rider_list_data': self.rider_list_data.to_json(),
'unknown_struct297': self.unknown_struct297.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_radius': 0.5, 'collision_offset': Vector(x=0.0, y=0.0, z=-0.699999988079071)})
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_common(data: typing.BinaryIO, property_size: int):
return PlayerCommonData.from_stream(data, property_size)
def _decode_mount_data(data: typing.BinaryIO, property_size: int):
return PlayerMountData.from_stream(data, property_size)
def _decode_rider_list_data(data: typing.BinaryIO, property_size: int):
return PlayerMountRiderList.from_stream(data, property_size)
def _decode_unknown_struct297(data: typing.BinaryIO, property_size: int):
return UnknownStruct297.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),
0xb3774750: ('patterned', _decode_patterned),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0x63f638: ('unknown_struct', _decode_unknown_struct),
0x3c38498d: ('common', _decode_common),
0x978e5bd8: ('mount_data', _decode_mount_data),
0x7f681411: ('rider_list_data', _decode_rider_list_data),
0x45b5b754: ('unknown_struct297', _decode_unknown_struct297),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/VerticalRocketBarrel.py | 0.538741 | 0.317664 | VerticalRocketBarrel.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 AVIS(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
visualization_file: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
texture_file: 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 'AVIS'
@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'\xb2Ulf') # 0xb2556c66
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.visualization_file))
data.write(b'B\tv\x86') # 0x42097686
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture_file))
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']),
visualization_file=data['visualization_file'],
texture_file=data['texture_file'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'visualization_file': self.visualization_file,
'texture_file': self.texture_file,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_visualization_file(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_texture_file(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),
0xb2556c66: ('visualization_file', _decode_visualization_file),
0x42097686: ('texture_file', _decode_texture_file),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AVIS.py | 0.59514 | 0.314458 | AVIS.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 MultiplayerSyncRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: 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 'MPSR'
@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\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
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']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(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),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MultiplayerSyncRelay.py | 0.6508 | 0.360433 | MultiplayerSyncRelay.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.UnknownStruct241 import UnknownStruct241
@dataclasses.dataclass()
class MusicMaster(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct241: UnknownStruct241 = dataclasses.field(default_factory=UnknownStruct241)
@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 'MUMA'
@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'\x17\xa8\x04\xe1') # 0x17a804e1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct241.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_struct241=UnknownStruct241.from_json(data['unknown_struct241']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct241': self.unknown_struct241.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct241(data: typing.BinaryIO, property_size: int):
return UnknownStruct241.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),
0x17a804e1: ('unknown_struct241', _decode_unknown_struct241),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/MusicMaster.py | 0.623033 | 0.351812 | MusicMaster.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 AreaDamage(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
pulse_time: float = dataclasses.field(default=1.0)
grace_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 'ADMG'
@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'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'\x8e\x07\xe9\xd3') # 0x8e07e9d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pulse_time))
data.write(b'\xc0R\xbc\x02') # 0xc052bc02
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grace_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']),
damage=DamageInfo.from_json(data['damage']),
pulse_time=data['pulse_time'],
grace_time=data['grace_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
'pulse_time': self.pulse_time,
'grace_time': self.grace_time,
}
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_pulse_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grace_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),
0x337f9524: ('damage', _decode_damage),
0x8e07e9d3: ('pulse_time', _decode_pulse_time),
0xc052bc02: ('grace_time', _decode_grace_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/AreaDamage.py | 0.638159 | 0.346652 | AreaDamage.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 StreamedMovie(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
movie_file: str = dataclasses.field(default='')
loop: bool = dataclasses.field(default=False)
video_filter_enabled: bool = dataclasses.field(default=True)
unknown: int = dataclasses.field(default=0)
volume: int = dataclasses.field(default=127)
volume_type: int = dataclasses.field(default=0)
cache_length: float = dataclasses.field(default=0.05000000074505806)
fade_out_time: float = dataclasses.field(default=1.0)
is_level_reveal: 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 'MOVI'
@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'X+\x84\xa8') # 0x582b84a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.movie_file.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'6\x96;\xcc') # 0x36963bcc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.video_filter_enabled))
data.write(b'\xa7\x8a\xc0\xc0') # 0xa78ac0c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\x80\xc6l7') # 0x80c66c37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume))
data.write(b'\xe1\xffO\x04') # 0xe1ff4f04
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume_type))
data.write(b'\xad\x9e\xb7\x7f') # 0xad9eb77f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cache_length))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'x\x1b\xa1\x15') # 0x781ba115
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_level_reveal))
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']),
movie_file=data['movie_file'],
loop=data['loop'],
video_filter_enabled=data['video_filter_enabled'],
unknown=data['unknown'],
volume=data['volume'],
volume_type=data['volume_type'],
cache_length=data['cache_length'],
fade_out_time=data['fade_out_time'],
is_level_reveal=data['is_level_reveal'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'movie_file': self.movie_file,
'loop': self.loop,
'video_filter_enabled': self.video_filter_enabled,
'unknown': self.unknown,
'volume': self.volume,
'volume_type': self.volume_type,
'cache_length': self.cache_length,
'fade_out_time': self.fade_out_time,
'is_level_reveal': self.is_level_reveal,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_movie_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_video_filter_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_cache_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_is_level_reveal(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),
0x582b84a8: ('movie_file', _decode_movie_file),
0xeda47ff6: ('loop', _decode_loop),
0x36963bcc: ('video_filter_enabled', _decode_video_filter_enabled),
0xa78ac0c0: ('unknown', _decode_unknown),
0x80c66c37: ('volume', _decode_volume),
0xe1ff4f04: ('volume_type', _decode_volume_type),
0xad9eb77f: ('cache_length', _decode_cache_length),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0x781ba115: ('is_level_reveal', _decode_is_level_reveal),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/StreamedMovie.py | 0.603465 | 0.370197 | StreamedMovie.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.BirdBossData import BirdBossData
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class BirdBoss(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
bird_boss_data: BirdBossData = dataclasses.field(default_factory=BirdBossData)
@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 'BIRD'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_BirdBoss.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'U/rB') # 0x552f7242
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bird_boss_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']),
bird_boss_data=BirdBossData.from_json(data['bird_boss_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(),
'bird_boss_data': self.bird_boss_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_bird_boss_data(data: typing.BinaryIO, property_size: int):
return BirdBossData.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),
0x552f7242: ('bird_boss_data', _decode_bird_boss_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/BirdBoss.py | 0.636579 | 0.368178 | BirdBoss.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 Relay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: 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 'SRLY'
@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\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
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']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(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),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Relay.py | 0.656768 | 0.364551 | Relay.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.SurroundPan import SurroundPan
from retro_data_structures.properties.dkc_returns.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Sound(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
min_audible_distance: float = dataclasses.field(default=0.0)
max_audible_distance: float = dataclasses.field(default=0.0)
delay_time: float = dataclasses.field(default=0.0)
volume: float = dataclasses.field(default=1.0)
volume_variance: float = dataclasses.field(default=0.0)
surround_pan: SurroundPan = dataclasses.field(default_factory=SurroundPan)
pan_variance: float = dataclasses.field(default=0.0)
pitch: float = dataclasses.field(default=0.0)
ambient: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
can_occlude: bool = dataclasses.field(default=False)
play_always: bool = dataclasses.field(default=False)
sound_is_music: bool = dataclasses.field(default=False)
update_velocity: bool = dataclasses.field(default=False)
ignore_generated_behavior: bool = dataclasses.field(default=False)
sound_is_ui_sound: bool = dataclasses.field(default=False)
sound_is_speech: 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 'SOND'
@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\x13') # 19 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\x1a1v') # 0x771a3176
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_effect))
data.write(b'%\xd4y\x8a') # 0x25d4798a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_audible_distance))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'\x8e\x16\xe0\x12') # 0x8e16e012
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_time))
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'\xf0\xe4KV') # 0xf0e44b56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_variance))
data.write(b'\x0b\xb6&9') # 0xbb62639
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surround_pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95#rX') # 0x95237258
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan_variance))
data.write(b',\xc5\xcb\x93') # 0x2cc5cb93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch))
data.write(b'\x89q\xb7\xa7') # 0x8971b7a7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ambient))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\x94r\x11c') # 0x94721163
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_occlude))
data.write(b'\r\x7f\x8c\x7f') # 0xd7f8c7f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.play_always))
data.write(b'v\xd4\x00\x91') # 0x76d40091
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_music))
data.write(b'\x90\x14\\\xd2') # 0x90145cd2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.update_velocity))
data.write(b'\xeb\xd1\x92s') # 0xebd19273
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_generated_behavior))
data.write(b'\x18oe\x92') # 0x186f6592
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_ui_sound))
data.write(b'^\to\xd2') # 0x5e096fd2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_speech))
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']),
sound_effect=data['sound_effect'],
min_audible_distance=data['min_audible_distance'],
max_audible_distance=data['max_audible_distance'],
delay_time=data['delay_time'],
volume=data['volume'],
volume_variance=data['volume_variance'],
surround_pan=SurroundPan.from_json(data['surround_pan']),
pan_variance=data['pan_variance'],
pitch=data['pitch'],
ambient=data['ambient'],
auto_start=data['auto_start'],
can_occlude=data['can_occlude'],
play_always=data['play_always'],
sound_is_music=data['sound_is_music'],
update_velocity=data['update_velocity'],
ignore_generated_behavior=data['ignore_generated_behavior'],
sound_is_ui_sound=data['sound_is_ui_sound'],
sound_is_speech=data['sound_is_speech'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'sound_effect': self.sound_effect,
'min_audible_distance': self.min_audible_distance,
'max_audible_distance': self.max_audible_distance,
'delay_time': self.delay_time,
'volume': self.volume,
'volume_variance': self.volume_variance,
'surround_pan': self.surround_pan.to_json(),
'pan_variance': self.pan_variance,
'pitch': self.pitch,
'ambient': self.ambient,
'auto_start': self.auto_start,
'can_occlude': self.can_occlude,
'play_always': self.play_always,
'sound_is_music': self.sound_is_music,
'update_velocity': self.update_velocity,
'ignore_generated_behavior': self.ignore_generated_behavior,
'sound_is_ui_sound': self.sound_is_ui_sound,
'sound_is_speech': self.sound_is_speech,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_min_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_surround_pan(data: typing.BinaryIO, property_size: int):
return SurroundPan.from_stream(data, property_size)
def _decode_pan_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient(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_can_occlude(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_play_always(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_music(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_update_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_generated_behavior(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_ui_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_speech(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),
0x771a3176: ('sound_effect', _decode_sound_effect),
0x25d4798a: ('min_audible_distance', _decode_min_audible_distance),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x8e16e012: ('delay_time', _decode_delay_time),
0xc7a7f189: ('volume', _decode_volume),
0xf0e44b56: ('volume_variance', _decode_volume_variance),
0xbb62639: ('surround_pan', _decode_surround_pan),
0x95237258: ('pan_variance', _decode_pan_variance),
0x2cc5cb93: ('pitch', _decode_pitch),
0x8971b7a7: ('ambient', _decode_ambient),
0x3217dff8: ('auto_start', _decode_auto_start),
0x94721163: ('can_occlude', _decode_can_occlude),
0xd7f8c7f: ('play_always', _decode_play_always),
0x76d40091: ('sound_is_music', _decode_sound_is_music),
0x90145cd2: ('update_velocity', _decode_update_velocity),
0xebd19273: ('ignore_generated_behavior', _decode_ignore_generated_behavior),
0x186f6592: ('sound_is_ui_sound', _decode_sound_is_ui_sound),
0x5e096fd2: ('sound_is_speech', _decode_sound_is_speech),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Sound.py | 0.582372 | 0.276105 | Sound.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.PlayerCommonData import PlayerCommonData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMountData import PlayerMountData
from retro_data_structures.properties.dkc_returns.archetypes.PlayerMountRiderList import PlayerMountRiderList
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.UnknownStruct250 import UnknownStruct250
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct252 import UnknownStruct252
from retro_data_structures.properties.dkc_returns.core.Vector import Vector
@dataclasses.dataclass()
class RocketBarrel(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct: UnknownStruct = dataclasses.field(default_factory=UnknownStruct)
common: PlayerCommonData = dataclasses.field(default_factory=PlayerCommonData)
mount_data: PlayerMountData = dataclasses.field(default_factory=PlayerMountData)
rider_list_data: PlayerMountRiderList = dataclasses.field(default_factory=PlayerMountRiderList)
unknown_struct250: UnknownStruct250 = dataclasses.field(default_factory=UnknownStruct250)
unknown_struct252: UnknownStruct252 = dataclasses.field(default_factory=UnknownStruct252)
@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 'RBRL'
@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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_radius': 0.5, 'collision_offset': Vector(x=0.0, y=0.0, z=-0.699999988079071)})
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'<8I\x8d') # 0x3c38498d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.common.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\x8e[\xd8') # 0x978e5bd8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mount_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x7fh\x14\x11') # 0x7f681411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rider_list_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\xf2@\xa8') # 0x15f240a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct250.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\x86%\x10') # 0x4a862510
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct252.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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct=UnknownStruct.from_json(data['unknown_struct']),
common=PlayerCommonData.from_json(data['common']),
mount_data=PlayerMountData.from_json(data['mount_data']),
rider_list_data=PlayerMountRiderList.from_json(data['rider_list_data']),
unknown_struct250=UnknownStruct250.from_json(data['unknown_struct250']),
unknown_struct252=UnknownStruct252.from_json(data['unknown_struct252']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct': self.unknown_struct.to_json(),
'common': self.common.to_json(),
'mount_data': self.mount_data.to_json(),
'rider_list_data': self.rider_list_data.to_json(),
'unknown_struct250': self.unknown_struct250.to_json(),
'unknown_struct252': self.unknown_struct252.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_radius': 0.5, 'collision_offset': Vector(x=0.0, y=0.0, z=-0.699999988079071)})
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_common(data: typing.BinaryIO, property_size: int):
return PlayerCommonData.from_stream(data, property_size)
def _decode_mount_data(data: typing.BinaryIO, property_size: int):
return PlayerMountData.from_stream(data, property_size)
def _decode_rider_list_data(data: typing.BinaryIO, property_size: int):
return PlayerMountRiderList.from_stream(data, property_size)
def _decode_unknown_struct250(data: typing.BinaryIO, property_size: int):
return UnknownStruct250.from_stream(data, property_size)
def _decode_unknown_struct252(data: typing.BinaryIO, property_size: int):
return UnknownStruct252.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),
0xb3774750: ('patterned', _decode_patterned),
0xbf81c83e: ('shadow_data', _decode_shadow_data),
0x7e397fed: ('actor_information', _decode_actor_information),
0x63f638: ('unknown_struct', _decode_unknown_struct),
0x3c38498d: ('common', _decode_common),
0x978e5bd8: ('mount_data', _decode_mount_data),
0x7f681411: ('rider_list_data', _decode_rider_list_data),
0x15f240a8: ('unknown_struct250', _decode_unknown_struct250),
0x4a862510: ('unknown_struct252', _decode_unknown_struct252),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/RocketBarrel.py | 0.528047 | 0.283945 | RocketBarrel.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 PositionRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: 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 'SPRL'
@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\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
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']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(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),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PositionRelay.py | 0.655115 | 0.362151 | PositionRelay.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.CameraInterpolation import CameraInterpolation
from retro_data_structures.properties.dkc_returns.archetypes.CameraOrientation import CameraOrientation
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.SavedStateID import SavedStateID
from retro_data_structures.properties.dkc_returns.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.dkc_returns.core.Spline import Spline
@dataclasses.dataclass()
class CinematicCamera(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
object_id: SavedStateID = dataclasses.field(default_factory=SavedStateID)
camera_mode: enums.CameraMode = dataclasses.field(default=enums.CameraMode.Unknown1)
use_script_object_transform: bool = dataclasses.field(default=False)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
cinematic_ends_type: enums.CinematicEndsType = dataclasses.field(default=enums.CinematicEndsType.Unknown1)
end_time: float = dataclasses.field(default=10.0)
unknown: int = dataclasses.field(default=133236)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
orientation_behavior: CameraOrientation = dataclasses.field(default_factory=CameraOrientation)
fov_spline: Spline = dataclasses.field(default_factory=Spline)
roll_spline: Spline = dataclasses.field(default_factory=Spline)
slowmo_control_spline: Spline = dataclasses.field(default_factory=Spline)
interpolation_behavior: CameraInterpolation = dataclasses.field(default_factory=CameraInterpolation)
near_plane_distance_spline: Spline = dataclasses.field(default_factory=Spline)
far_plane_distance_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 'CINE'
@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'\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'\xcc\x08\xef\x1b') # 0xcc08ef1b
data.write(b'\x00\x04') # size
self.camera_mode.to_stream(data)
data.write(b'c\x87\xe4K') # 0x6387e44b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_script_object_transform))
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'\x97J\x96\x1f') # 0x974a961f
data.write(b'\x00\x04') # size
self.cinematic_ends_type.to_stream(data)
data.write(b'\xab\x81Q\xea') # 0xab8151ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.end_time))
data.write(b'\x05\xc5\xfcn') # 0x5c5fc6e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xdf\xbf\xa7') # 0xc4dfbfa7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'e\xfc\x11\xff') # 0x65fc11ff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_behavior.to_stream(data, default_override={'orientation_type': 648890987, 'flags_orientation': 12})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'hh\xd4\xb3') # 0x6868d4b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'nm\x8e\xfd') # 0x6e6d8efd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.roll_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf4\xf4y\x8e') # 0xf4f4798e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.slowmo_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"vH'\xd4") # 0x764827d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.interpolation_behavior.to_stream(data, default_override={'on_flags': 0, 'off_flags': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b')QX\x02') # 0x29515802
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.near_plane_distance_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\x18e\xa6') # 0xdf1865a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.far_plane_distance_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']),
object_id=SavedStateID.from_json(data['object_id']),
camera_mode=enums.CameraMode.from_json(data['camera_mode']),
use_script_object_transform=data['use_script_object_transform'],
animation=AnimationParameters.from_json(data['animation']),
cinematic_ends_type=enums.CinematicEndsType.from_json(data['cinematic_ends_type']),
end_time=data['end_time'],
unknown=data['unknown'],
motion_control_spline=Spline.from_json(data['motion_control_spline']),
target_control_spline=Spline.from_json(data['target_control_spline']),
orientation_behavior=CameraOrientation.from_json(data['orientation_behavior']),
fov_spline=Spline.from_json(data['fov_spline']),
roll_spline=Spline.from_json(data['roll_spline']),
slowmo_control_spline=Spline.from_json(data['slowmo_control_spline']),
interpolation_behavior=CameraInterpolation.from_json(data['interpolation_behavior']),
near_plane_distance_spline=Spline.from_json(data['near_plane_distance_spline']),
far_plane_distance_spline=Spline.from_json(data['far_plane_distance_spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'object_id': self.object_id.to_json(),
'camera_mode': self.camera_mode.to_json(),
'use_script_object_transform': self.use_script_object_transform,
'animation': self.animation.to_json(),
'cinematic_ends_type': self.cinematic_ends_type.to_json(),
'end_time': self.end_time,
'unknown': self.unknown,
'motion_control_spline': self.motion_control_spline.to_json(),
'target_control_spline': self.target_control_spline.to_json(),
'orientation_behavior': self.orientation_behavior.to_json(),
'fov_spline': self.fov_spline.to_json(),
'roll_spline': self.roll_spline.to_json(),
'slowmo_control_spline': self.slowmo_control_spline.to_json(),
'interpolation_behavior': self.interpolation_behavior.to_json(),
'near_plane_distance_spline': self.near_plane_distance_spline.to_json(),
'far_plane_distance_spline': self.far_plane_distance_spline.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_camera_mode(data: typing.BinaryIO, property_size: int):
return enums.CameraMode.from_stream(data)
def _decode_use_script_object_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_cinematic_ends_type(data: typing.BinaryIO, property_size: int):
return enums.CinematicEndsType.from_stream(data)
def _decode_end_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_orientation_behavior(data: typing.BinaryIO, property_size: int):
return CameraOrientation.from_stream(data, property_size, default_override={'orientation_type': 648890987, 'flags_orientation': 12})
def _decode_fov_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_roll_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_slowmo_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_interpolation_behavior(data: typing.BinaryIO, property_size: int):
return CameraInterpolation.from_stream(data, property_size, default_override={'on_flags': 0, 'off_flags': 0})
def _decode_near_plane_distance_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_far_plane_distance_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),
0x16d9a75d: ('object_id', _decode_object_id),
0xcc08ef1b: ('camera_mode', _decode_camera_mode),
0x6387e44b: ('use_script_object_transform', _decode_use_script_object_transform),
0xa3d63f44: ('animation', _decode_animation),
0x974a961f: ('cinematic_ends_type', _decode_cinematic_ends_type),
0xab8151ea: ('end_time', _decode_end_time),
0x5c5fc6e: ('unknown', _decode_unknown),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0x65fc11ff: ('orientation_behavior', _decode_orientation_behavior),
0x6868d4b3: ('fov_spline', _decode_fov_spline),
0x6e6d8efd: ('roll_spline', _decode_roll_spline),
0xf4f4798e: ('slowmo_control_spline', _decode_slowmo_control_spline),
0x764827d4: ('interpolation_behavior', _decode_interpolation_behavior),
0x29515802: ('near_plane_distance_spline', _decode_near_plane_distance_spline),
0xdf1865a6: ('far_plane_distance_spline', _decode_far_plane_distance_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/CinematicCamera.py | 0.584983 | 0.294913 | CinematicCamera.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 Retronome(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time_offset: float = dataclasses.field(default=0.0)
unknown_0x2d458535: bool = dataclasses.field(default=True)
unknown_0xa598ca16: bool = dataclasses.field(default=False)
unknown_0xc9c29626: bool = dataclasses.field(default=False)
unknown_0x4e599427: bool = dataclasses.field(default=False)
unknown_0xb7329cec: 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 'RTNM'
@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'%9\xdeF') # 0x2539de46
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_offset))
data.write(b'-E\x855') # 0x2d458535
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2d458535))
data.write(b'\xa5\x98\xca\x16') # 0xa598ca16
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa598ca16))
data.write(b'\xc9\xc2\x96&') # 0xc9c29626
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc9c29626))
data.write(b"NY\x94'") # 0x4e599427
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4e599427))
data.write(b'\xb72\x9c\xec') # 0xb7329cec
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb7329cec))
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_offset=data['time_offset'],
unknown_0x2d458535=data['unknown_0x2d458535'],
unknown_0xa598ca16=data['unknown_0xa598ca16'],
unknown_0xc9c29626=data['unknown_0xc9c29626'],
unknown_0x4e599427=data['unknown_0x4e599427'],
unknown_0xb7329cec=data['unknown_0xb7329cec'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time_offset': self.time_offset,
'unknown_0x2d458535': self.unknown_0x2d458535,
'unknown_0xa598ca16': self.unknown_0xa598ca16,
'unknown_0xc9c29626': self.unknown_0xc9c29626,
'unknown_0x4e599427': self.unknown_0x4e599427,
'unknown_0xb7329cec': self.unknown_0xb7329cec,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2d458535(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa598ca16(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xc9c29626(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4e599427(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb7329cec(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),
0x2539de46: ('time_offset', _decode_time_offset),
0x2d458535: ('unknown_0x2d458535', _decode_unknown_0x2d458535),
0xa598ca16: ('unknown_0xa598ca16', _decode_unknown_0xa598ca16),
0xc9c29626: ('unknown_0xc9c29626', _decode_unknown_0xc9c29626),
0x4e599427: ('unknown_0x4e599427', _decode_unknown_0x4e599427),
0xb7329cec: ('unknown_0xb7329cec', _decode_unknown_0xb7329cec),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/Retronome.py | 0.624637 | 0.362941 | Retronome.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.dkc_returns.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.dkc_returns.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.dkc_returns.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.dkc_returns.archetypes.ShadowData import ShadowData
from retro_data_structures.properties.dkc_returns.archetypes.UnknownStruct89 import UnknownStruct89
@dataclasses.dataclass()
class PirateCrab(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_data: ShadowData = dataclasses.field(default_factory=ShadowData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
unknown_struct89: UnknownStruct89 = dataclasses.field(default_factory=UnknownStruct89)
@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 'CRAB'
@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\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x81\xc8>') # 0xbf81c83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shadow_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xf8\xbad") # 0x27f8ba64
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct89.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_data=ShadowData.from_json(data['shadow_data']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
unknown_struct89=UnknownStruct89.from_json(data['unknown_struct89']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_data': self.shadow_data.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned': self.patterned.to_json(),
'unknown_struct89': self.unknown_struct89.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_data(data: typing.BinaryIO, property_size: int):
return ShadowData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'collision_height': 1.0})
def _decode_unknown_struct89(data: typing.BinaryIO, property_size: int):
return UnknownStruct89.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),
0x27f8ba64: ('unknown_struct89', _decode_unknown_struct89),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PirateCrab.py | 0.634543 | 0.355719 | PirateCrab.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.UnknownStruct247 import UnknownStruct247
@dataclasses.dataclass()
class PoiObject(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct247: UnknownStruct247 = dataclasses.field(default_factory=UnknownStruct247)
@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 'POIO'
@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'\x98WN\xb1') # 0x98574eb1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct247.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_struct247=UnknownStruct247.from_json(data['unknown_struct247']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct247': self.unknown_struct247.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct247(data: typing.BinaryIO, property_size: int):
return UnknownStruct247.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),
0x98574eb1: ('unknown_struct247', _decode_unknown_struct247),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/PoiObject.py | 0.614625 | 0.353205 | PoiObject.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.SquawkProxyData import SquawkProxyData
@dataclasses.dataclass()
class SquawkProxy(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
squawk_proxy_data: SquawkProxyData = dataclasses.field(default_factory=SquawkProxyData)
@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 'SWKP'
@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'l\xea\xa8\xda') # 0x6ceaa8da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.squawk_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']),
squawk_proxy_data=SquawkProxyData.from_json(data['squawk_proxy_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'squawk_proxy_data': self.squawk_proxy_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_squawk_proxy_data(data: typing.BinaryIO, property_size: int):
return SquawkProxyData.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),
0x6ceaa8da: ('squawk_proxy_data', _decode_squawk_proxy_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/dkc_returns/objects/SquawkProxy.py | 0.625552 | 0.359083 | SquawkProxy.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.ShockWaveInfo import ShockWaveInfo
@dataclasses.dataclass()
class MetroidHopperStruct(BaseProperty):
hypermode_shockwave: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
hypermode_chance: float = dataclasses.field(default=0.10000000149011612)
hypermode_duration: float = dataclasses.field(default=10.0)
hypermode_delay: float = dataclasses.field(default=20.0)
hyper_mode_initial_delay: float = dataclasses.field(default=15.0)
hypermode_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'\xf8\xe4^\x84') # 0xf8e45e84
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.hypermode_shockwave.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\xa0Mp') # 0x1ca04d70
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hypermode_chance))
data.write(b'\x8dP\x8c\xa7') # 0x8d508ca7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hypermode_duration))
data.write(b'\xc9\xbaGF') # 0xc9ba4746
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hypermode_delay))
data.write(b'\xe1t\xf4c') # 0xe174f463
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hyper_mode_initial_delay))
data.write(b'\xd1R(1') # 0xd1522831
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.hypermode_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
hypermode_shockwave=ShockWaveInfo.from_json(data['hypermode_shockwave']),
hypermode_chance=data['hypermode_chance'],
hypermode_duration=data['hypermode_duration'],
hypermode_delay=data['hypermode_delay'],
hyper_mode_initial_delay=data['hyper_mode_initial_delay'],
hypermode_vulnerability=DamageVulnerability.from_json(data['hypermode_vulnerability']),
)
def to_json(self) -> dict:
return {
'hypermode_shockwave': self.hypermode_shockwave.to_json(),
'hypermode_chance': self.hypermode_chance,
'hypermode_duration': self.hypermode_duration,
'hypermode_delay': self.hypermode_delay,
'hyper_mode_initial_delay': self.hyper_mode_initial_delay,
'hypermode_vulnerability': self.hypermode_vulnerability.to_json(),
}
def _decode_hypermode_shockwave(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.from_stream(data, property_size)
def _decode_hypermode_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hypermode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hypermode_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hyper_mode_initial_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hypermode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf8e45e84: ('hypermode_shockwave', _decode_hypermode_shockwave),
0x1ca04d70: ('hypermode_chance', _decode_hypermode_chance),
0x8d508ca7: ('hypermode_duration', _decode_hypermode_duration),
0xc9ba4746: ('hypermode_delay', _decode_hypermode_delay),
0xe174f463: ('hyper_mode_initial_delay', _decode_hyper_mode_initial_delay),
0xd1522831: ('hypermode_vulnerability', _decode_hypermode_vulnerability),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/MetroidHopperStruct.py | 0.602997 | 0.230292 | MetroidHopperStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class ContextActionCombinationLockStruct(BaseProperty):
initial_angle: float = dataclasses.field(default=0.0)
unlock_angle: float = dataclasses.field(default=0.0)
min_angle: float = dataclasses.field(default=-90.0)
max_angle: float = dataclasses.field(default=90.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x90\xac\x80A') # 0x90ac8041
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_angle))
data.write(b'\x89\xc4\xcc_') # 0x89c4cc5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unlock_angle))
data.write(b'\x99,-\xf5') # 0x992c2df5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_angle))
data.write(b'\xd9cU\x83') # 0xd9635583
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_angle))
@classmethod
def from_json(cls, data: dict):
return cls(
initial_angle=data['initial_angle'],
unlock_angle=data['unlock_angle'],
min_angle=data['min_angle'],
max_angle=data['max_angle'],
)
def to_json(self) -> dict:
return {
'initial_angle': self.initial_angle,
'unlock_angle': self.unlock_angle,
'min_angle': self.min_angle,
'max_angle': self.max_angle,
}
_FAST_FORMAT = None
_FAST_IDS = (0x90ac8041, 0x89c4cc5f, 0x992c2df5, 0xd9635583)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ContextActionCombinationLockStruct]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return ContextActionCombinationLockStruct(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_initial_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unlock_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x90ac8041: ('initial_angle', _decode_initial_angle),
0x89c4cc5f: ('unlock_angle', _decode_unlock_angle),
0x992c2df5: ('min_angle', _decode_min_angle),
0xd9635583: ('max_angle', _decode_max_angle),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/ContextActionCombinationLockStruct.py | 0.589244 | 0.350977 | ContextActionCombinationLockStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
@dataclasses.dataclass()
class UnknownStruct21(BaseProperty):
difficulty: enums.BerserkerEnum = dataclasses.field(default=enums.BerserkerEnum.Unknown4)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'+\x08,m') # 0x2b082c6d
data.write(b'\x00\x04') # size
self.difficulty.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
difficulty=enums.BerserkerEnum.from_json(data['difficulty']),
)
def to_json(self) -> dict:
return {
'difficulty': self.difficulty.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x2b082c6d)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct21]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct21(
enums.BerserkerEnum(dec[2]),
)
def _decode_difficulty(data: typing.BinaryIO, property_size: int):
return enums.BerserkerEnum.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x2b082c6d: ('difficulty', _decode_difficulty),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct21.py | 0.62498 | 0.281346 | UnknownStruct21.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Armor(BaseProperty):
has_armor: bool = dataclasses.field(default=False)
armor_health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
armor_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
head_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collar_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
left_collar_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
right_collar_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
spine1_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
spine2_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
left_hip_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
right_hip_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
skeleton_root_armor_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\xfd\xe9\xc4\xdf') # 0xfde9c4df
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.has_armor))
data.write(b'\xf1\x83\x84\xd4') # 0xf18384d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.armor_health.to_stream(data, default_override={'health': 100.0, 'hi_knock_back_resistance': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89m[\xd9') # 0x896d5bd9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.armor_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h\x00+\xd7') # 0x68002bd7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.head_armor_model))
data.write(b'\xad1\\|') # 0xad315c7c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collar_armor_model))
data.write(b'\x04*%\xed') # 0x42a25ed
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_collar_armor_model))
data.write(b'\xe3\x9b\x8b\x1e') # 0xe39b8b1e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_collar_armor_model))
data.write(b'5l\x16j') # 0x356c166a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.spine1_armor_model))
data.write(b'\x1c\xa4\xa2\x98') # 0x1ca4a298
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.spine2_armor_model))
data.write(b'\xdfDP~') # 0xdf44507e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_hip_armor_model))
data.write(b'\xd2\xc9\xa6V') # 0xd2c9a656
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_hip_armor_model))
data.write(b'\xd4\xe2j\x8e') # 0xd4e26a8e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.skeleton_root_armor_model))
@classmethod
def from_json(cls, data: dict):
return cls(
has_armor=data['has_armor'],
armor_health=HealthInfo.from_json(data['armor_health']),
armor_vulnerability=DamageVulnerability.from_json(data['armor_vulnerability']),
head_armor_model=data['head_armor_model'],
collar_armor_model=data['collar_armor_model'],
left_collar_armor_model=data['left_collar_armor_model'],
right_collar_armor_model=data['right_collar_armor_model'],
spine1_armor_model=data['spine1_armor_model'],
spine2_armor_model=data['spine2_armor_model'],
left_hip_armor_model=data['left_hip_armor_model'],
right_hip_armor_model=data['right_hip_armor_model'],
skeleton_root_armor_model=data['skeleton_root_armor_model'],
)
def to_json(self) -> dict:
return {
'has_armor': self.has_armor,
'armor_health': self.armor_health.to_json(),
'armor_vulnerability': self.armor_vulnerability.to_json(),
'head_armor_model': self.head_armor_model,
'collar_armor_model': self.collar_armor_model,
'left_collar_armor_model': self.left_collar_armor_model,
'right_collar_armor_model': self.right_collar_armor_model,
'spine1_armor_model': self.spine1_armor_model,
'spine2_armor_model': self.spine2_armor_model,
'left_hip_armor_model': self.left_hip_armor_model,
'right_hip_armor_model': self.right_hip_armor_model,
'skeleton_root_armor_model': self.skeleton_root_armor_model,
}
def _decode_has_armor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_armor_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size, default_override={'health': 100.0, 'hi_knock_back_resistance': 5.0})
def _decode_armor_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_head_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collar_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_collar_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_collar_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_spine1_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_spine2_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_hip_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_hip_armor_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_skeleton_root_armor_model(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]]] = {
0xfde9c4df: ('has_armor', _decode_has_armor),
0xf18384d4: ('armor_health', _decode_armor_health),
0x896d5bd9: ('armor_vulnerability', _decode_armor_vulnerability),
0x68002bd7: ('head_armor_model', _decode_head_armor_model),
0xad315c7c: ('collar_armor_model', _decode_collar_armor_model),
0x42a25ed: ('left_collar_armor_model', _decode_left_collar_armor_model),
0xe39b8b1e: ('right_collar_armor_model', _decode_right_collar_armor_model),
0x356c166a: ('spine1_armor_model', _decode_spine1_armor_model),
0x1ca4a298: ('spine2_armor_model', _decode_spine2_armor_model),
0xdf44507e: ('left_hip_armor_model', _decode_left_hip_armor_model),
0xd2c9a656: ('right_hip_armor_model', _decode_right_hip_armor_model),
0xd4e26a8e: ('skeleton_root_armor_model', _decode_skeleton_root_armor_model),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/Armor.py | 0.578805 | 0.220405 | Armor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class ScaleSplines(BaseProperty):
x_scale: Spline = dataclasses.field(default_factory=Spline)
y_scale: Spline = dataclasses.field(default_factory=Spline)
z_scale: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xf47\xa6/') # 0xf437a62f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'o\x92\xea@') # 0x6f92ea40
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18\x0c8\xb0') # 0x180c38b0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_scale.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_scale=Spline.from_json(data['x_scale']),
y_scale=Spline.from_json(data['y_scale']),
z_scale=Spline.from_json(data['z_scale']),
)
def to_json(self) -> dict:
return {
'x_scale': self.x_scale.to_json(),
'y_scale': self.y_scale.to_json(),
'z_scale': self.z_scale.to_json(),
}
def _decode_x_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_scale(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_scale(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]]] = {
0xf437a62f: ('x_scale', _decode_x_scale),
0x6f92ea40: ('y_scale', _decode_y_scale),
0x180c38b0: ('z_scale', _decode_z_scale),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/ScaleSplines.py | 0.618665 | 0.304591 | ScaleSplines.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.archetypes.LightParameters import LightParameters
from retro_data_structures.properties.corruption.archetypes.ScannableParameters import ScannableParameters
from retro_data_structures.properties.corruption.archetypes.VisorParameters import VisorParameters
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ActorParameters(BaseProperty):
lighting: LightParameters = dataclasses.field(default_factory=LightParameters)
scannable: ScannableParameters = dataclasses.field(default_factory=ScannableParameters)
x_ray_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
x_ray_skin: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
use_global_render_time: bool = dataclasses.field(default=True)
fade_in_time: float = dataclasses.field(default=1.0)
fade_out_time: float = dataclasses.field(default=1.0)
visor: VisorParameters = dataclasses.field(default_factory=VisorParameters)
force_render_unsorted: bool = dataclasses.field(default=False)
takes_projected_shadow: bool = dataclasses.field(default=True)
unknown_0xf07981e8: bool = dataclasses.field(default=False)
unknown_0x4d55f7d4: bool = dataclasses.field(default=False)
actor_material_type: enums.ActorMaterialType = dataclasses.field(default=enums.ActorMaterialType.kMT_Unknown)
actor_collision_response: enums.ActorCollisionResponse = dataclasses.field(default=enums.ActorCollisionResponse.kACR_Default)
max_volume: int = dataclasses.field(default=127)
is_hostile: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x10') # 16 properties
data.write(b'\xb0(\xdb\x0e') # 0xb028db0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'7[\xfd|') # 0x375bfd7c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scannable.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbbR\xf0\xbe') # 0xbb52f0be
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.x_ray_model))
data.write(b'\xc6Gu[') # 0xc647755b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.x_ray_skin))
data.write(b'\x14\x99\x80<') # 0x1499803c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_global_render_time))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\x05\xad%\x0e') # 0x5ad250e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.visor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'y\x92c\xf1') # 0x799263f1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_render_unsorted))
data.write(b'\xed:n\x87') # 0xed3a6e87
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.takes_projected_shadow))
data.write(b'\xf0y\x81\xe8') # 0xf07981e8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf07981e8))
data.write(b'MU\xf7\xd4') # 0x4d55f7d4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4d55f7d4))
data.write(b'\xe3\x15\xeer') # 0xe315ee72
data.write(b'\x00\x04') # size
self.actor_material_type.to_stream(data)
data.write(b'X8\x95\xfa') # 0x583895fa
data.write(b'\x00\x04') # size
self.actor_collision_response.to_stream(data)
data.write(b'\xc7\x12\x84|') # 0xc712847c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_volume))
data.write(b'p\x1ba\xb3') # 0x701b61b3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_hostile))
@classmethod
def from_json(cls, data: dict):
return cls(
lighting=LightParameters.from_json(data['lighting']),
scannable=ScannableParameters.from_json(data['scannable']),
x_ray_model=data['x_ray_model'],
x_ray_skin=data['x_ray_skin'],
use_global_render_time=data['use_global_render_time'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
visor=VisorParameters.from_json(data['visor']),
force_render_unsorted=data['force_render_unsorted'],
takes_projected_shadow=data['takes_projected_shadow'],
unknown_0xf07981e8=data['unknown_0xf07981e8'],
unknown_0x4d55f7d4=data['unknown_0x4d55f7d4'],
actor_material_type=enums.ActorMaterialType.from_json(data['actor_material_type']),
actor_collision_response=enums.ActorCollisionResponse.from_json(data['actor_collision_response']),
max_volume=data['max_volume'],
is_hostile=data['is_hostile'],
)
def to_json(self) -> dict:
return {
'lighting': self.lighting.to_json(),
'scannable': self.scannable.to_json(),
'x_ray_model': self.x_ray_model,
'x_ray_skin': self.x_ray_skin,
'use_global_render_time': self.use_global_render_time,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'visor': self.visor.to_json(),
'force_render_unsorted': self.force_render_unsorted,
'takes_projected_shadow': self.takes_projected_shadow,
'unknown_0xf07981e8': self.unknown_0xf07981e8,
'unknown_0x4d55f7d4': self.unknown_0x4d55f7d4,
'actor_material_type': self.actor_material_type.to_json(),
'actor_collision_response': self.actor_collision_response.to_json(),
'max_volume': self.max_volume,
'is_hostile': self.is_hostile,
}
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightParameters.from_stream(data, property_size)
def _decode_scannable(data: typing.BinaryIO, property_size: int):
return ScannableParameters.from_stream(data, property_size)
def _decode_x_ray_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_x_ray_skin(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_use_global_render_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visor(data: typing.BinaryIO, property_size: int):
return VisorParameters.from_stream(data, property_size)
def _decode_force_render_unsorted(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_takes_projected_shadow(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf07981e8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4d55f7d4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_actor_material_type(data: typing.BinaryIO, property_size: int):
return enums.ActorMaterialType.from_stream(data)
def _decode_actor_collision_response(data: typing.BinaryIO, property_size: int):
return enums.ActorCollisionResponse.from_stream(data)
def _decode_max_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_hostile(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]]] = {
0xb028db0e: ('lighting', _decode_lighting),
0x375bfd7c: ('scannable', _decode_scannable),
0xbb52f0be: ('x_ray_model', _decode_x_ray_model),
0xc647755b: ('x_ray_skin', _decode_x_ray_skin),
0x1499803c: ('use_global_render_time', _decode_use_global_render_time),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0x5ad250e: ('visor', _decode_visor),
0x799263f1: ('force_render_unsorted', _decode_force_render_unsorted),
0xed3a6e87: ('takes_projected_shadow', _decode_takes_projected_shadow),
0xf07981e8: ('unknown_0xf07981e8', _decode_unknown_0xf07981e8),
0x4d55f7d4: ('unknown_0x4d55f7d4', _decode_unknown_0x4d55f7d4),
0xe315ee72: ('actor_material_type', _decode_actor_material_type),
0x583895fa: ('actor_collision_response', _decode_actor_collision_response),
0xc712847c: ('max_volume', _decode_max_volume),
0x701b61b3: ('is_hostile', _decode_is_hostile),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/ActorParameters.py | 0.558447 | 0.245537 | ActorParameters.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.ShockWaveInfo import ShockWaveInfo
@dataclasses.dataclass()
class DefenseMechanoidData(BaseProperty):
unknown_0xd41f1468: bool = dataclasses.field(default=True)
unknown_0x77259804: bool = dataclasses.field(default=True)
unknown_0xec877653: float = dataclasses.field(default=200.0)
unknown_0x09555889: float = dataclasses.field(default=45.0)
unknown_0x5ceca2a6: float = dataclasses.field(default=100.0)
jammer_antenna_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
command_core_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0x6735f19b: float = dataclasses.field(default=25.0)
unknown_0x0a9689e2: float = dataclasses.field(default=25.0)
unknown_0xa65f4b32: float = dataclasses.field(default=25.0)
unknown_0x78871ce9: float = dataclasses.field(default=25.0)
min_jump_interval: float = dataclasses.field(default=15.0)
max_jump_interval: float = dataclasses.field(default=25.0)
min_missile_interval: float = dataclasses.field(default=1.5)
max_missile_interval: float = dataclasses.field(default=3.0)
min_taunt_interval: float = dataclasses.field(default=10.0)
max_taunt_interval: float = dataclasses.field(default=20.0)
min_distance_adjust_interval: float = dataclasses.field(default=7.0)
max_distance_adjust_interval: float = dataclasses.field(default=12.0)
unknown_0xbc801a3e: float = dataclasses.field(default=4.0)
unknown_0xc060b62b: float = dataclasses.field(default=10.0)
unknown_0x2766a717: float = dataclasses.field(default=50.0)
unknown_0x29ea27db: float = dataclasses.field(default=10.0)
missile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
huge_missile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
pulse_shockwave: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
seeker_bomb_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1b') # 27 properties
data.write(b'\xd4\x1f\x14h') # 0xd41f1468
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd41f1468))
data.write(b'w%\x98\x04') # 0x77259804
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x77259804))
data.write(b'\xec\x87vS') # 0xec877653
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xec877653))
data.write(b'\tUX\x89') # 0x9555889
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x09555889))
data.write(b'\\\xec\xa2\xa6') # 0x5ceca2a6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5ceca2a6))
data.write(b'\xff\x8c@V') # 0xff8c4056
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.jammer_antenna_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x99\xbb\xc2\xde') # 0x99bbc2de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.command_core_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'g5\xf1\x9b') # 0x6735f19b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6735f19b))
data.write(b'\n\x96\x89\xe2') # 0xa9689e2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0a9689e2))
data.write(b'\xa6_K2') # 0xa65f4b32
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa65f4b32))
data.write(b'x\x87\x1c\xe9') # 0x78871ce9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x78871ce9))
data.write(b'\xcd\xf4\xd7U') # 0xcdf4d755
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_jump_interval))
data.write(b'\xe4\x8a*M') # 0xe48a2a4d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_jump_interval))
data.write(b'\xed"6\x86') # 0xed223686
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_missile_interval))
data.write(b'\xe9\xb8\x07\xac') # 0xe9b807ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_missile_interval))
data.write(b'3\xa2\x98\xcd') # 0x33a298cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_taunt_interval))
data.write(b' \xe7~f') # 0x20e77e66
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_taunt_interval))
data.write(b'\xaa\xfe>C') # 0xaafe3e43
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_distance_adjust_interval))
data.write(b'\x1a\xc1$\x7f') # 0x1ac1247f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_distance_adjust_interval))
data.write(b'\xbc\x80\x1a>') # 0xbc801a3e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbc801a3e))
data.write(b'\xc0`\xb6+') # 0xc060b62b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc060b62b))
data.write(b"'f\xa7\x17") # 0x2766a717
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2766a717))
data.write(b")\xea'\xdb") # 0x29ea27db
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x29ea27db))
data.write(b'%\x8c\xfbM') # 0x258cfb4d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.missile_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf4\xd9\x9a\xbc') # 0xf4d99abc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.huge_missile_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe1|;n') # 0xe17c3b6e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pulse_shockwave.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'YU\tR') # 0x59550952
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seeker_bomb_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xd41f1468=data['unknown_0xd41f1468'],
unknown_0x77259804=data['unknown_0x77259804'],
unknown_0xec877653=data['unknown_0xec877653'],
unknown_0x09555889=data['unknown_0x09555889'],
unknown_0x5ceca2a6=data['unknown_0x5ceca2a6'],
jammer_antenna_vulnerability=DamageVulnerability.from_json(data['jammer_antenna_vulnerability']),
command_core_vulnerability=DamageVulnerability.from_json(data['command_core_vulnerability']),
unknown_0x6735f19b=data['unknown_0x6735f19b'],
unknown_0x0a9689e2=data['unknown_0x0a9689e2'],
unknown_0xa65f4b32=data['unknown_0xa65f4b32'],
unknown_0x78871ce9=data['unknown_0x78871ce9'],
min_jump_interval=data['min_jump_interval'],
max_jump_interval=data['max_jump_interval'],
min_missile_interval=data['min_missile_interval'],
max_missile_interval=data['max_missile_interval'],
min_taunt_interval=data['min_taunt_interval'],
max_taunt_interval=data['max_taunt_interval'],
min_distance_adjust_interval=data['min_distance_adjust_interval'],
max_distance_adjust_interval=data['max_distance_adjust_interval'],
unknown_0xbc801a3e=data['unknown_0xbc801a3e'],
unknown_0xc060b62b=data['unknown_0xc060b62b'],
unknown_0x2766a717=data['unknown_0x2766a717'],
unknown_0x29ea27db=data['unknown_0x29ea27db'],
missile_damage=DamageInfo.from_json(data['missile_damage']),
huge_missile_damage=DamageInfo.from_json(data['huge_missile_damage']),
pulse_shockwave=ShockWaveInfo.from_json(data['pulse_shockwave']),
seeker_bomb_damage=DamageInfo.from_json(data['seeker_bomb_damage']),
)
def to_json(self) -> dict:
return {
'unknown_0xd41f1468': self.unknown_0xd41f1468,
'unknown_0x77259804': self.unknown_0x77259804,
'unknown_0xec877653': self.unknown_0xec877653,
'unknown_0x09555889': self.unknown_0x09555889,
'unknown_0x5ceca2a6': self.unknown_0x5ceca2a6,
'jammer_antenna_vulnerability': self.jammer_antenna_vulnerability.to_json(),
'command_core_vulnerability': self.command_core_vulnerability.to_json(),
'unknown_0x6735f19b': self.unknown_0x6735f19b,
'unknown_0x0a9689e2': self.unknown_0x0a9689e2,
'unknown_0xa65f4b32': self.unknown_0xa65f4b32,
'unknown_0x78871ce9': self.unknown_0x78871ce9,
'min_jump_interval': self.min_jump_interval,
'max_jump_interval': self.max_jump_interval,
'min_missile_interval': self.min_missile_interval,
'max_missile_interval': self.max_missile_interval,
'min_taunt_interval': self.min_taunt_interval,
'max_taunt_interval': self.max_taunt_interval,
'min_distance_adjust_interval': self.min_distance_adjust_interval,
'max_distance_adjust_interval': self.max_distance_adjust_interval,
'unknown_0xbc801a3e': self.unknown_0xbc801a3e,
'unknown_0xc060b62b': self.unknown_0xc060b62b,
'unknown_0x2766a717': self.unknown_0x2766a717,
'unknown_0x29ea27db': self.unknown_0x29ea27db,
'missile_damage': self.missile_damage.to_json(),
'huge_missile_damage': self.huge_missile_damage.to_json(),
'pulse_shockwave': self.pulse_shockwave.to_json(),
'seeker_bomb_damage': self.seeker_bomb_damage.to_json(),
}
def _decode_unknown_0xd41f1468(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x77259804(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xec877653(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x09555889(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5ceca2a6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jammer_antenna_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_command_core_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0x6735f19b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0a9689e2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa65f4b32(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x78871ce9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_jump_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_jump_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_missile_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_missile_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_taunt_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_taunt_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_distance_adjust_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_distance_adjust_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbc801a3e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc060b62b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2766a717(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x29ea27db(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_missile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_huge_missile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_pulse_shockwave(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.from_stream(data, property_size)
def _decode_seeker_bomb_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd41f1468: ('unknown_0xd41f1468', _decode_unknown_0xd41f1468),
0x77259804: ('unknown_0x77259804', _decode_unknown_0x77259804),
0xec877653: ('unknown_0xec877653', _decode_unknown_0xec877653),
0x9555889: ('unknown_0x09555889', _decode_unknown_0x09555889),
0x5ceca2a6: ('unknown_0x5ceca2a6', _decode_unknown_0x5ceca2a6),
0xff8c4056: ('jammer_antenna_vulnerability', _decode_jammer_antenna_vulnerability),
0x99bbc2de: ('command_core_vulnerability', _decode_command_core_vulnerability),
0x6735f19b: ('unknown_0x6735f19b', _decode_unknown_0x6735f19b),
0xa9689e2: ('unknown_0x0a9689e2', _decode_unknown_0x0a9689e2),
0xa65f4b32: ('unknown_0xa65f4b32', _decode_unknown_0xa65f4b32),
0x78871ce9: ('unknown_0x78871ce9', _decode_unknown_0x78871ce9),
0xcdf4d755: ('min_jump_interval', _decode_min_jump_interval),
0xe48a2a4d: ('max_jump_interval', _decode_max_jump_interval),
0xed223686: ('min_missile_interval', _decode_min_missile_interval),
0xe9b807ac: ('max_missile_interval', _decode_max_missile_interval),
0x33a298cd: ('min_taunt_interval', _decode_min_taunt_interval),
0x20e77e66: ('max_taunt_interval', _decode_max_taunt_interval),
0xaafe3e43: ('min_distance_adjust_interval', _decode_min_distance_adjust_interval),
0x1ac1247f: ('max_distance_adjust_interval', _decode_max_distance_adjust_interval),
0xbc801a3e: ('unknown_0xbc801a3e', _decode_unknown_0xbc801a3e),
0xc060b62b: ('unknown_0xc060b62b', _decode_unknown_0xc060b62b),
0x2766a717: ('unknown_0x2766a717', _decode_unknown_0x2766a717),
0x29ea27db: ('unknown_0x29ea27db', _decode_unknown_0x29ea27db),
0x258cfb4d: ('missile_damage', _decode_missile_damage),
0xf4d99abc: ('huge_missile_damage', _decode_huge_missile_damage),
0xe17c3b6e: ('pulse_shockwave', _decode_pulse_shockwave),
0x59550952: ('seeker_bomb_damage', _decode_seeker_bomb_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/DefenseMechanoidData.py | 0.553264 | 0.262397 | DefenseMechanoidData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.TWeaponDamage import TWeaponDamage
@dataclasses.dataclass()
class TBeamInfo(BaseProperty):
cooldown: float = dataclasses.field(default=0.20000000298023224)
damage_info: TWeaponDamage = dataclasses.field(default_factory=TWeaponDamage)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\x10.\x08_') # 0x102e085f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cooldown))
data.write(b'\xfa\xa7\x1e%') # 0xfaa71e25
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
cooldown=data['cooldown'],
damage_info=TWeaponDamage.from_json(data['damage_info']),
)
def to_json(self) -> dict:
return {
'cooldown': self.cooldown,
'damage_info': self.damage_info.to_json(),
}
def _decode_cooldown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_info(data: typing.BinaryIO, property_size: int):
return TWeaponDamage.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x102e085f: ('cooldown', _decode_cooldown),
0xfaa71e25: ('damage_info', _decode_damage_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/TBeamInfo.py | 0.589716 | 0.285981 | TBeamInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.FOVInterpolationMethod import FOVInterpolationMethod
from retro_data_structures.properties.corruption.archetypes.MotionInterpolationMethod import MotionInterpolationMethod
from retro_data_structures.properties.corruption.archetypes.OrientationInterpolationMethod import OrientationInterpolationMethod
@dataclasses.dataclass()
class CinematicBlend(BaseProperty):
motion_blend: MotionInterpolationMethod = dataclasses.field(default_factory=MotionInterpolationMethod)
orientation_blend: OrientationInterpolationMethod = dataclasses.field(default_factory=OrientationInterpolationMethod)
fov_blend: FOVInterpolationMethod = dataclasses.field(default_factory=FOVInterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\xb5\xc3g\xe9') # 0xb5c367e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_blend.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7O\x8c\x89') # 0xf74f8c89
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_blend.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18\xe6\xbe\xd2') # 0x18e6bed2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_blend.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
motion_blend=MotionInterpolationMethod.from_json(data['motion_blend']),
orientation_blend=OrientationInterpolationMethod.from_json(data['orientation_blend']),
fov_blend=FOVInterpolationMethod.from_json(data['fov_blend']),
)
def to_json(self) -> dict:
return {
'motion_blend': self.motion_blend.to_json(),
'orientation_blend': self.orientation_blend.to_json(),
'fov_blend': self.fov_blend.to_json(),
}
def _decode_motion_blend(data: typing.BinaryIO, property_size: int):
return MotionInterpolationMethod.from_stream(data, property_size)
def _decode_orientation_blend(data: typing.BinaryIO, property_size: int):
return OrientationInterpolationMethod.from_stream(data, property_size)
def _decode_fov_blend(data: typing.BinaryIO, property_size: int):
return FOVInterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xb5c367e9: ('motion_blend', _decode_motion_blend),
0xf74f8c89: ('orientation_blend', _decode_orientation_blend),
0x18e6bed2: ('fov_blend', _decode_fov_blend),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/CinematicBlend.py | 0.630912 | 0.316488 | CinematicBlend.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.GhorStructA import GhorStructA
@dataclasses.dataclass()
class UnknownStruct35(BaseProperty):
ghor_struct_a_0x8b5db983: GhorStructA = dataclasses.field(default_factory=GhorStructA)
ghor_struct_a_0x04cdc6a6: GhorStructA = dataclasses.field(default_factory=GhorStructA)
ghor_struct_a_0xe451d02c: GhorStructA = dataclasses.field(default_factory=GhorStructA)
ghor_struct_a_0x72f708f2: GhorStructA = dataclasses.field(default_factory=GhorStructA)
ghor_struct_a_0x8cb41734: GhorStructA = dataclasses.field(default_factory=GhorStructA)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x05') # 5 properties
data.write(b'\x8b]\xb9\x83') # 0x8b5db983
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ghor_struct_a_0x8b5db983.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x04\xcd\xc6\xa6') # 0x4cdc6a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ghor_struct_a_0x04cdc6a6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4Q\xd0,') # 0xe451d02c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ghor_struct_a_0xe451d02c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'r\xf7\x08\xf2') # 0x72f708f2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ghor_struct_a_0x72f708f2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8c\xb4\x174') # 0x8cb41734
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ghor_struct_a_0x8cb41734.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
ghor_struct_a_0x8b5db983=GhorStructA.from_json(data['ghor_struct_a_0x8b5db983']),
ghor_struct_a_0x04cdc6a6=GhorStructA.from_json(data['ghor_struct_a_0x04cdc6a6']),
ghor_struct_a_0xe451d02c=GhorStructA.from_json(data['ghor_struct_a_0xe451d02c']),
ghor_struct_a_0x72f708f2=GhorStructA.from_json(data['ghor_struct_a_0x72f708f2']),
ghor_struct_a_0x8cb41734=GhorStructA.from_json(data['ghor_struct_a_0x8cb41734']),
)
def to_json(self) -> dict:
return {
'ghor_struct_a_0x8b5db983': self.ghor_struct_a_0x8b5db983.to_json(),
'ghor_struct_a_0x04cdc6a6': self.ghor_struct_a_0x04cdc6a6.to_json(),
'ghor_struct_a_0xe451d02c': self.ghor_struct_a_0xe451d02c.to_json(),
'ghor_struct_a_0x72f708f2': self.ghor_struct_a_0x72f708f2.to_json(),
'ghor_struct_a_0x8cb41734': self.ghor_struct_a_0x8cb41734.to_json(),
}
def _decode_ghor_struct_a_0x8b5db983(data: typing.BinaryIO, property_size: int):
return GhorStructA.from_stream(data, property_size)
def _decode_ghor_struct_a_0x04cdc6a6(data: typing.BinaryIO, property_size: int):
return GhorStructA.from_stream(data, property_size)
def _decode_ghor_struct_a_0xe451d02c(data: typing.BinaryIO, property_size: int):
return GhorStructA.from_stream(data, property_size)
def _decode_ghor_struct_a_0x72f708f2(data: typing.BinaryIO, property_size: int):
return GhorStructA.from_stream(data, property_size)
def _decode_ghor_struct_a_0x8cb41734(data: typing.BinaryIO, property_size: int):
return GhorStructA.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8b5db983: ('ghor_struct_a_0x8b5db983', _decode_ghor_struct_a_0x8b5db983),
0x4cdc6a6: ('ghor_struct_a_0x04cdc6a6', _decode_ghor_struct_a_0x04cdc6a6),
0xe451d02c: ('ghor_struct_a_0xe451d02c', _decode_ghor_struct_a_0xe451d02c),
0x72f708f2: ('ghor_struct_a_0x72f708f2', _decode_ghor_struct_a_0x72f708f2),
0x8cb41734: ('ghor_struct_a_0x8cb41734', _decode_ghor_struct_a_0x8cb41734),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct35.py | 0.564819 | 0.372334 | UnknownStruct35.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
@dataclasses.dataclass()
class UnknownStruct8(BaseProperty):
beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
attack_duration: float = dataclasses.field(default=8.0)
unknown_0x47cde539: float = dataclasses.field(default=0.5)
turn_speed: float = dataclasses.field(default=20.0)
unknown_0x82bd3b10: float = dataclasses.field(default=15.0)
acceleration_time: float = dataclasses.field(default=3.0)
min_fire_dist: float = dataclasses.field(default=20.0)
max_fire_dist: float = dataclasses.field(default=75.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x15\x98\x01*') # 0x1598012a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_info.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'\x164,\x18') # 0x16342c18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_duration))
data.write(b'G\xcd\xe59') # 0x47cde539
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x47cde539))
data.write(b'\x02\x0cx\xbb') # 0x20c78bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turn_speed))
data.write(b'\x82\xbd;\x10') # 0x82bd3b10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x82bd3b10))
data.write(b'\x1a\x1a1Z') # 0x1a1a315a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.acceleration_time))
data.write(b'p\x07q\xb7') # 0x700771b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_fire_dist))
data.write(b'!\xfe\xca\xea') # 0x21fecaea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_fire_dist))
@classmethod
def from_json(cls, data: dict):
return cls(
beam_info=PlasmaBeamInfo.from_json(data['beam_info']),
damage=DamageInfo.from_json(data['damage']),
attack_duration=data['attack_duration'],
unknown_0x47cde539=data['unknown_0x47cde539'],
turn_speed=data['turn_speed'],
unknown_0x82bd3b10=data['unknown_0x82bd3b10'],
acceleration_time=data['acceleration_time'],
min_fire_dist=data['min_fire_dist'],
max_fire_dist=data['max_fire_dist'],
)
def to_json(self) -> dict:
return {
'beam_info': self.beam_info.to_json(),
'damage': self.damage.to_json(),
'attack_duration': self.attack_duration,
'unknown_0x47cde539': self.unknown_0x47cde539,
'turn_speed': self.turn_speed,
'unknown_0x82bd3b10': self.unknown_0x82bd3b10,
'acceleration_time': self.acceleration_time,
'min_fire_dist': self.min_fire_dist,
'max_fire_dist': self.max_fire_dist,
}
def _decode_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_attack_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x47cde539(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x82bd3b10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_acceleration_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_fire_dist(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_fire_dist(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]]] = {
0x1598012a: ('beam_info', _decode_beam_info),
0x337f9524: ('damage', _decode_damage),
0x16342c18: ('attack_duration', _decode_attack_duration),
0x47cde539: ('unknown_0x47cde539', _decode_unknown_0x47cde539),
0x20c78bb: ('turn_speed', _decode_turn_speed),
0x82bd3b10: ('unknown_0x82bd3b10', _decode_unknown_0x82bd3b10),
0x1a1a315a: ('acceleration_time', _decode_acceleration_time),
0x700771b7: ('min_fire_dist', _decode_min_fire_dist),
0x21fecaea: ('max_fire_dist', _decode_max_fire_dist),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct8.py | 0.607197 | 0.339253 | UnknownStruct8.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct65(BaseProperty):
world: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
use_skybox: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'1\xec\x14\xbc') # 0x31ec14bc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.world))
data.write(b'\xa9\t\xf8\xd3') # 0xa909f8d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.use_skybox.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
world=data['world'],
use_skybox=data['use_skybox'],
)
def to_json(self) -> dict:
return {
'world': self.world,
'use_skybox': self.use_skybox,
}
def _decode_world(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_use_skybox(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x31ec14bc: ('world', _decode_world),
0xa909f8d3: ('use_skybox', _decode_use_skybox),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct65.py | 0.604866 | 0.254474 | UnknownStruct65.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PTCNoseTurretData(BaseProperty):
aiming_prediction: float = dataclasses.field(default=0.5)
scanning_range_min: float = dataclasses.field(default=-90.0)
scanning_range_max: float = dataclasses.field(default=90.0)
scanning_speed: float = dataclasses.field(default=90.0)
max_detection_angle: float = dataclasses.field(default=90.0)
unknown_0x494be648: float = dataclasses.field(default=0.0)
max_attack_angle: float = dataclasses.field(default=15.0)
max_rotation_speed: float = dataclasses.field(default=360.0)
max_rotation: float = dataclasses.field(default=135.0)
min_rotation: float = dataclasses.field(default=-135.0)
max_pitch_speed: float = dataclasses.field(default=360.0)
max_pitch: float = dataclasses.field(default=45.0)
min_pitch: float = dataclasses.field(default=-45.0)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
burst_delay: float = dataclasses.field(default=1.0)
unknown_0xb5702ca3: int = dataclasses.field(default=3)
burst_shot_delay: float = dataclasses.field(default=0.10000000149011612)
unknown_0xaf28dc00: int = dataclasses.field(default=2)
sound_shot: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x55d9abef: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x15') # 21 properties
data.write(b'9[\x81\xef') # 0x395b81ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.aiming_prediction))
data.write(b'D\xe0\x13w') # 0x44e01377
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scanning_range_min))
data.write(b'\xa2\x80\xbc\x96') # 0xa280bc96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scanning_range_max))
data.write(b'\xf7\x1cm\xd7') # 0xf71c6dd7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scanning_speed))
data.write(b'g\x90(\xba') # 0x679028ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_detection_angle))
data.write(b'IK\xe6H') # 0x494be648
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x494be648))
data.write(b'\xf1\x1fs\x84') # 0xf11f7384
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_angle))
data.write(b'P\xee\xb9\xe3') # 0x50eeb9e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_rotation_speed))
data.write(b'w!\xde\xea') # 0x7721deea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_rotation))
data.write(b'&\xd8e\xb7') # 0x26d865b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_rotation))
data.write(b'\x95\x97\xa3)') # 0x9597a329
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_pitch_speed))
data.write(b'\xcd\x8c\x87c') # 0xcd8c8763
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_pitch))
data.write(b'\x8d\xc3\xff\x15') # 0x8dc3ff15
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_pitch))
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.projectile))
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'\xeb\x904s') # 0xeb903473
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.burst_delay))
data.write(b'\xb5p,\xa3') # 0xb5702ca3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xb5702ca3))
data.write(b'\xe8\xf2\x9e\x1e') # 0xe8f29e1e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.burst_shot_delay))
data.write(b'\xaf(\xdc\x00') # 0xaf28dc00
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xaf28dc00))
data.write(b'\xc2:\x19U') # 0xc23a1955
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_shot))
data.write(b'U\xd9\xab\xef') # 0x55d9abef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x55d9abef))
@classmethod
def from_json(cls, data: dict):
return cls(
aiming_prediction=data['aiming_prediction'],
scanning_range_min=data['scanning_range_min'],
scanning_range_max=data['scanning_range_max'],
scanning_speed=data['scanning_speed'],
max_detection_angle=data['max_detection_angle'],
unknown_0x494be648=data['unknown_0x494be648'],
max_attack_angle=data['max_attack_angle'],
max_rotation_speed=data['max_rotation_speed'],
max_rotation=data['max_rotation'],
min_rotation=data['min_rotation'],
max_pitch_speed=data['max_pitch_speed'],
max_pitch=data['max_pitch'],
min_pitch=data['min_pitch'],
projectile=data['projectile'],
damage=DamageInfo.from_json(data['damage']),
burst_delay=data['burst_delay'],
unknown_0xb5702ca3=data['unknown_0xb5702ca3'],
burst_shot_delay=data['burst_shot_delay'],
unknown_0xaf28dc00=data['unknown_0xaf28dc00'],
sound_shot=data['sound_shot'],
unknown_0x55d9abef=data['unknown_0x55d9abef'],
)
def to_json(self) -> dict:
return {
'aiming_prediction': self.aiming_prediction,
'scanning_range_min': self.scanning_range_min,
'scanning_range_max': self.scanning_range_max,
'scanning_speed': self.scanning_speed,
'max_detection_angle': self.max_detection_angle,
'unknown_0x494be648': self.unknown_0x494be648,
'max_attack_angle': self.max_attack_angle,
'max_rotation_speed': self.max_rotation_speed,
'max_rotation': self.max_rotation,
'min_rotation': self.min_rotation,
'max_pitch_speed': self.max_pitch_speed,
'max_pitch': self.max_pitch,
'min_pitch': self.min_pitch,
'projectile': self.projectile,
'damage': self.damage.to_json(),
'burst_delay': self.burst_delay,
'unknown_0xb5702ca3': self.unknown_0xb5702ca3,
'burst_shot_delay': self.burst_shot_delay,
'unknown_0xaf28dc00': self.unknown_0xaf28dc00,
'sound_shot': self.sound_shot,
'unknown_0x55d9abef': self.unknown_0x55d9abef,
}
def _decode_aiming_prediction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scanning_range_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scanning_range_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scanning_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x494be648(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_rotation_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_pitch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_burst_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb5702ca3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_burst_shot_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xaf28dc00(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x55d9abef(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]]] = {
0x395b81ef: ('aiming_prediction', _decode_aiming_prediction),
0x44e01377: ('scanning_range_min', _decode_scanning_range_min),
0xa280bc96: ('scanning_range_max', _decode_scanning_range_max),
0xf71c6dd7: ('scanning_speed', _decode_scanning_speed),
0x679028ba: ('max_detection_angle', _decode_max_detection_angle),
0x494be648: ('unknown_0x494be648', _decode_unknown_0x494be648),
0xf11f7384: ('max_attack_angle', _decode_max_attack_angle),
0x50eeb9e3: ('max_rotation_speed', _decode_max_rotation_speed),
0x7721deea: ('max_rotation', _decode_max_rotation),
0x26d865b7: ('min_rotation', _decode_min_rotation),
0x9597a329: ('max_pitch_speed', _decode_max_pitch_speed),
0xcd8c8763: ('max_pitch', _decode_max_pitch),
0x8dc3ff15: ('min_pitch', _decode_min_pitch),
0xef485db9: ('projectile', _decode_projectile),
0x337f9524: ('damage', _decode_damage),
0xeb903473: ('burst_delay', _decode_burst_delay),
0xb5702ca3: ('unknown_0xb5702ca3', _decode_unknown_0xb5702ca3),
0xe8f29e1e: ('burst_shot_delay', _decode_burst_shot_delay),
0xaf28dc00: ('unknown_0xaf28dc00', _decode_unknown_0xaf28dc00),
0xc23a1955: ('sound_shot', _decode_sound_shot),
0x55d9abef: ('unknown_0x55d9abef', _decode_unknown_0x55d9abef),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/PTCNoseTurretData.py | 0.578091 | 0.289227 | PTCNoseTurretData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.LayerInfo import LayerInfo
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Color import Color
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class RainProperties(BaseProperty):
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.1490200012922287))
velocity: float = dataclasses.field(default=-40.0)
min_length: float = dataclasses.field(default=1.0)
max_length: float = dataclasses.field(default=3.0)
near_width: float = dataclasses.field(default=6.0)
far_width: float = dataclasses.field(default=6.0)
unknown: float = dataclasses.field(default=50.0)
sheet_texture: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
sheet_motion: LayerInfo = dataclasses.field(default_factory=LayerInfo)
enable_sheet: bool = dataclasses.field(default=True)
rain_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
density_volume_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\x02\xf0\x16\x83') # 0x2f01683
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.velocity))
data.write(b'\xc6\x16\t=') # 0xc616093d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_length))
data.write(b'\x7f0\x92L') # 0x7f30924c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_length))
data.write(b'\xae\xadRY') # 0xaead5259
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.near_width))
data.write(b'\xf4\xf4\xe8V') # 0xf4f4e856
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_width))
data.write(b'p\x8d\xfe\x03') # 0x708dfe03
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'3\x99\xd6[') # 0x3399d65b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sheet_texture))
data.write(b'\x84v\xc5|') # 0x8476c57c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.sheet_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']\xebMW') # 0x5deb4d57
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_sheet))
data.write(b'55Z\x0b') # 0x35355a0b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rain_sound))
data.write(b'\x1aY\xb7\x81') # 0x1a59b781
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.density_volume_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
color=Color.from_json(data['color']),
velocity=data['velocity'],
min_length=data['min_length'],
max_length=data['max_length'],
near_width=data['near_width'],
far_width=data['far_width'],
unknown=data['unknown'],
sheet_texture=data['sheet_texture'],
sheet_motion=LayerInfo.from_json(data['sheet_motion']),
enable_sheet=data['enable_sheet'],
rain_sound=data['rain_sound'],
density_volume_spline=Spline.from_json(data['density_volume_spline']),
)
def to_json(self) -> dict:
return {
'color': self.color.to_json(),
'velocity': self.velocity,
'min_length': self.min_length,
'max_length': self.max_length,
'near_width': self.near_width,
'far_width': self.far_width,
'unknown': self.unknown,
'sheet_texture': self.sheet_texture,
'sheet_motion': self.sheet_motion.to_json(),
'enable_sheet': self.enable_sheet,
'rain_sound': self.rain_sound,
'density_volume_spline': self.density_volume_spline.to_json(),
}
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_near_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_width(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sheet_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sheet_motion(data: typing.BinaryIO, property_size: int):
return LayerInfo.from_stream(data, property_size)
def _decode_enable_sheet(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rain_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_density_volume_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]]] = {
0x37c7d09d: ('color', _decode_color),
0x2f01683: ('velocity', _decode_velocity),
0xc616093d: ('min_length', _decode_min_length),
0x7f30924c: ('max_length', _decode_max_length),
0xaead5259: ('near_width', _decode_near_width),
0xf4f4e856: ('far_width', _decode_far_width),
0x708dfe03: ('unknown', _decode_unknown),
0x3399d65b: ('sheet_texture', _decode_sheet_texture),
0x8476c57c: ('sheet_motion', _decode_sheet_motion),
0x5deb4d57: ('enable_sheet', _decode_enable_sheet),
0x35355a0b: ('rain_sound', _decode_rain_sound),
0x1a59b781: ('density_volume_spline', _decode_density_volume_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/RainProperties.py | 0.645455 | 0.242766 | RainProperties.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.ElectricBeamInfo import ElectricBeamInfo
from retro_data_structures.properties.corruption.archetypes.FlyerMovementMode import FlyerMovementMode
from retro_data_structures.properties.corruption.archetypes.GrappleData import GrappleData
from retro_data_structures.properties.corruption.archetypes.LaunchProjectileData import LaunchProjectileData
from retro_data_structures.properties.corruption.archetypes.ModIncaData import ModIncaData
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class GragnolFlyerData(BaseProperty):
shooter: bool = dataclasses.field(default=False)
projectile: LaunchProjectileData = dataclasses.field(default_factory=LaunchProjectileData)
missile_deflection_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
missile_deflection_radius: float = dataclasses.field(default=20.0)
missile_deflection_rate: float = dataclasses.field(default=120.0)
beam_weapon_info: ElectricBeamInfo = dataclasses.field(default_factory=ElectricBeamInfo)
deflection_particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
beam_deflection_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xf10ee8e2: float = dataclasses.field(default=-1.0)
unknown_0x7171bfc2: float = dataclasses.field(default=5.0)
electric_beam_info: ElectricBeamInfo = dataclasses.field(default_factory=ElectricBeamInfo)
patrol: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
attack_path: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
attack: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
grapple_pull_distance: float = dataclasses.field(default=5.0)
min_idle_delay: float = dataclasses.field(default=2.0)
max_idle_delay: float = dataclasses.field(default=10.0)
recheck_path_time: float = dataclasses.field(default=1.0)
recheck_path_distance: float = dataclasses.field(default=5.0)
unknown_0xdff6c19b: bool = dataclasses.field(default=False)
unknown_0xf7381a24: bool = dataclasses.field(default=True)
unknown_0xb2c2928e: float = dataclasses.field(default=5.0)
grapple_data: GrappleData = dataclasses.field(default_factory=GrappleData)
mod_inca_data: ModIncaData = dataclasses.field(default_factory=ModIncaData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x10') # 16 properties
num_properties_written = 16
data.write(b'\x8a\xcc} ') # 0x8acc7d20
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.shooter))
if self.projectile != default_override.get('projectile', LaunchProjectileData()):
num_properties_written += 1
data.write(b',\x83\xc0\x12') # 0x2c83c012
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'z\xb4\xab\x98') # 0x7ab4ab98
data.write(b'\x00\x0c') # size
self.missile_deflection_offset.to_stream(data)
if self.missile_deflection_radius != default_override.get('missile_deflection_radius', 20.0):
num_properties_written += 1
data.write(b'\x88\xfa*\xcf') # 0x88fa2acf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.missile_deflection_radius))
if self.missile_deflection_rate != default_override.get('missile_deflection_rate', 120.0):
num_properties_written += 1
data.write(b'\x1d\x15\x982') # 0x1d159832
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.missile_deflection_rate))
if self.beam_weapon_info != default_override.get('beam_weapon_info', ElectricBeamInfo()):
num_properties_written += 1
data.write(b'\x05\x01Wu') # 0x5015775
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_weapon_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.deflection_particle != default_override.get('deflection_particle', default_asset_id):
num_properties_written += 1
data.write(b'\x8f\x1d\xed\x1b') # 0x8f1ded1b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.deflection_particle))
if self.beam_deflection_sound != default_override.get('beam_deflection_sound', default_asset_id):
num_properties_written += 1
data.write(b'\x0b3\x9f\xac') # 0xb339fac
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.beam_deflection_sound))
data.write(b'\xf1\x0e\xe8\xe2') # 0xf10ee8e2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf10ee8e2))
data.write(b'qq\xbf\xc2') # 0x7171bfc2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7171bfc2))
if self.electric_beam_info != default_override.get('electric_beam_info', ElectricBeamInfo()):
num_properties_written += 1
data.write(b'$&X9') # 0x24265839
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.electric_beam_info.to_stream(data, default_override={'length': 50.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc\xdd:\xca') # 0xccdd3aca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patrol.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8E\xd3\xc0') # 0xc845d3c0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_path.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa*\x17?') # 0xfa2a173f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7L\xf5\x83') # 0xe74cf583
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grapple_pull_distance))
data.write(b'\x17k\xd1\xf4') # 0x176bd1f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_idle_delay))
data.write(b'\x02\xe0\x05\x06') # 0x2e00506
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_idle_delay))
data.write(b'\x9a\xa9\x0bk') # 0x9aa90b6b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.recheck_path_time))
data.write(b'v&\xec\x89') # 0x7626ec89
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.recheck_path_distance))
data.write(b'\xdf\xf6\xc1\x9b') # 0xdff6c19b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xdff6c19b))
data.write(b'\xf78\x1a$') # 0xf7381a24
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf7381a24))
data.write(b'\xb2\xc2\x92\x8e') # 0xb2c2928e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb2c2928e))
if self.grapple_data != default_override.get('grapple_data', GrappleData()):
num_properties_written += 1
data.write(b'\xf6\t\xc67') # 0xf609c637
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grapple_data.to_stream(data, default_override={'grapple_type': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\xc0(T') # 0xb4c02854
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mod_inca_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if num_properties_written != 16:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
shooter=data['shooter'],
projectile=LaunchProjectileData.from_json(data['projectile']),
missile_deflection_offset=Vector.from_json(data['missile_deflection_offset']),
missile_deflection_radius=data['missile_deflection_radius'],
missile_deflection_rate=data['missile_deflection_rate'],
beam_weapon_info=ElectricBeamInfo.from_json(data['beam_weapon_info']),
deflection_particle=data['deflection_particle'],
beam_deflection_sound=data['beam_deflection_sound'],
unknown_0xf10ee8e2=data['unknown_0xf10ee8e2'],
unknown_0x7171bfc2=data['unknown_0x7171bfc2'],
electric_beam_info=ElectricBeamInfo.from_json(data['electric_beam_info']),
patrol=FlyerMovementMode.from_json(data['patrol']),
attack_path=FlyerMovementMode.from_json(data['attack_path']),
attack=FlyerMovementMode.from_json(data['attack']),
grapple_pull_distance=data['grapple_pull_distance'],
min_idle_delay=data['min_idle_delay'],
max_idle_delay=data['max_idle_delay'],
recheck_path_time=data['recheck_path_time'],
recheck_path_distance=data['recheck_path_distance'],
unknown_0xdff6c19b=data['unknown_0xdff6c19b'],
unknown_0xf7381a24=data['unknown_0xf7381a24'],
unknown_0xb2c2928e=data['unknown_0xb2c2928e'],
grapple_data=GrappleData.from_json(data['grapple_data']),
mod_inca_data=ModIncaData.from_json(data['mod_inca_data']),
)
def to_json(self) -> dict:
return {
'shooter': self.shooter,
'projectile': self.projectile.to_json(),
'missile_deflection_offset': self.missile_deflection_offset.to_json(),
'missile_deflection_radius': self.missile_deflection_radius,
'missile_deflection_rate': self.missile_deflection_rate,
'beam_weapon_info': self.beam_weapon_info.to_json(),
'deflection_particle': self.deflection_particle,
'beam_deflection_sound': self.beam_deflection_sound,
'unknown_0xf10ee8e2': self.unknown_0xf10ee8e2,
'unknown_0x7171bfc2': self.unknown_0x7171bfc2,
'electric_beam_info': self.electric_beam_info.to_json(),
'patrol': self.patrol.to_json(),
'attack_path': self.attack_path.to_json(),
'attack': self.attack.to_json(),
'grapple_pull_distance': self.grapple_pull_distance,
'min_idle_delay': self.min_idle_delay,
'max_idle_delay': self.max_idle_delay,
'recheck_path_time': self.recheck_path_time,
'recheck_path_distance': self.recheck_path_distance,
'unknown_0xdff6c19b': self.unknown_0xdff6c19b,
'unknown_0xf7381a24': self.unknown_0xf7381a24,
'unknown_0xb2c2928e': self.unknown_0xb2c2928e,
'grapple_data': self.grapple_data.to_json(),
'mod_inca_data': self.mod_inca_data.to_json(),
}
def _decode_shooter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return LaunchProjectileData.from_stream(data, property_size)
def _decode_missile_deflection_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_missile_deflection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_missile_deflection_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_beam_weapon_info(data: typing.BinaryIO, property_size: int):
return ElectricBeamInfo.from_stream(data, property_size)
def _decode_deflection_particle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_beam_deflection_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xf10ee8e2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7171bfc2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_electric_beam_info(data: typing.BinaryIO, property_size: int):
return ElectricBeamInfo.from_stream(data, property_size, default_override={'length': 50.0})
def _decode_patrol(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_attack_path(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_attack(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_grapple_pull_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_idle_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_idle_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_recheck_path_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_recheck_path_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xdff6c19b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf7381a24(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb2c2928e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grapple_data(data: typing.BinaryIO, property_size: int):
return GrappleData.from_stream(data, property_size, default_override={'grapple_type': 1})
def _decode_mod_inca_data(data: typing.BinaryIO, property_size: int):
return ModIncaData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8acc7d20: ('shooter', _decode_shooter),
0x2c83c012: ('projectile', _decode_projectile),
0x7ab4ab98: ('missile_deflection_offset', _decode_missile_deflection_offset),
0x88fa2acf: ('missile_deflection_radius', _decode_missile_deflection_radius),
0x1d159832: ('missile_deflection_rate', _decode_missile_deflection_rate),
0x5015775: ('beam_weapon_info', _decode_beam_weapon_info),
0x8f1ded1b: ('deflection_particle', _decode_deflection_particle),
0xb339fac: ('beam_deflection_sound', _decode_beam_deflection_sound),
0xf10ee8e2: ('unknown_0xf10ee8e2', _decode_unknown_0xf10ee8e2),
0x7171bfc2: ('unknown_0x7171bfc2', _decode_unknown_0x7171bfc2),
0x24265839: ('electric_beam_info', _decode_electric_beam_info),
0xccdd3aca: ('patrol', _decode_patrol),
0xc845d3c0: ('attack_path', _decode_attack_path),
0xfa2a173f: ('attack', _decode_attack),
0xe74cf583: ('grapple_pull_distance', _decode_grapple_pull_distance),
0x176bd1f4: ('min_idle_delay', _decode_min_idle_delay),
0x2e00506: ('max_idle_delay', _decode_max_idle_delay),
0x9aa90b6b: ('recheck_path_time', _decode_recheck_path_time),
0x7626ec89: ('recheck_path_distance', _decode_recheck_path_distance),
0xdff6c19b: ('unknown_0xdff6c19b', _decode_unknown_0xdff6c19b),
0xf7381a24: ('unknown_0xf7381a24', _decode_unknown_0xf7381a24),
0xb2c2928e: ('unknown_0xb2c2928e', _decode_unknown_0xb2c2928e),
0xf609c637: ('grapple_data', _decode_grapple_data),
0xb4c02854: ('mod_inca_data', _decode_mod_inca_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/GragnolFlyerData.py | 0.521959 | 0.228727 | GragnolFlyerData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.PlayerInventoryItem import PlayerInventoryItem
@dataclasses.dataclass()
class Misc(BaseProperty):
energy: PlayerInventoryItem = dataclasses.field(default_factory=PlayerInventoryItem)
energy_tank: PlayerInventoryItem = dataclasses.field(default_factory=PlayerInventoryItem)
fuses: PlayerInventoryItem = dataclasses.field(default_factory=PlayerInventoryItem)
player_inventory_item: PlayerInventoryItem = dataclasses.field(default_factory=PlayerInventoryItem)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'3k\xd4q') # 0x336bd471
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.energy.to_stream(data, default_override={'amount': 1, 'capacity': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd3\x1b"\t') # 0xd31b2209
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.energy_tank.to_stream(data, default_override={'amount': 1, 'capacity': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15.\xd0\xd9') # 0x152ed0d9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fuses.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\n\x91\xae') # 0x950a91ae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_inventory_item.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
energy=PlayerInventoryItem.from_json(data['energy']),
energy_tank=PlayerInventoryItem.from_json(data['energy_tank']),
fuses=PlayerInventoryItem.from_json(data['fuses']),
player_inventory_item=PlayerInventoryItem.from_json(data['player_inventory_item']),
)
def to_json(self) -> dict:
return {
'energy': self.energy.to_json(),
'energy_tank': self.energy_tank.to_json(),
'fuses': self.fuses.to_json(),
'player_inventory_item': self.player_inventory_item.to_json(),
}
def _decode_energy(data: typing.BinaryIO, property_size: int):
return PlayerInventoryItem.from_stream(data, property_size, default_override={'amount': 1, 'capacity': 1})
def _decode_energy_tank(data: typing.BinaryIO, property_size: int):
return PlayerInventoryItem.from_stream(data, property_size, default_override={'amount': 1, 'capacity': 1})
def _decode_fuses(data: typing.BinaryIO, property_size: int):
return PlayerInventoryItem.from_stream(data, property_size)
def _decode_player_inventory_item(data: typing.BinaryIO, property_size: int):
return PlayerInventoryItem.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x336bd471: ('energy', _decode_energy),
0xd31b2209: ('energy_tank', _decode_energy_tank),
0x152ed0d9: ('fuses', _decode_fuses),
0x950a91ae: ('player_inventory_item', _decode_player_inventory_item),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/Misc.py | 0.642208 | 0.333164 | Misc.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
@dataclasses.dataclass()
class KorbaMawData(BaseProperty):
bite_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x200f67e7: float = dataclasses.field(default=0.5)
unknown_0xe54de3e1: float = dataclasses.field(default=3.0)
unknown_0x8a821fee: float = dataclasses.field(default=2.799999952316284)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xdfclK') # 0xdf636c4b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bite_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' \x0fg\xe7') # 0x200f67e7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x200f67e7))
data.write(b'\xe5M\xe3\xe1') # 0xe54de3e1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe54de3e1))
data.write(b'\x8a\x82\x1f\xee') # 0x8a821fee
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8a821fee))
@classmethod
def from_json(cls, data: dict):
return cls(
bite_damage=DamageInfo.from_json(data['bite_damage']),
unknown_0x200f67e7=data['unknown_0x200f67e7'],
unknown_0xe54de3e1=data['unknown_0xe54de3e1'],
unknown_0x8a821fee=data['unknown_0x8a821fee'],
)
def to_json(self) -> dict:
return {
'bite_damage': self.bite_damage.to_json(),
'unknown_0x200f67e7': self.unknown_0x200f67e7,
'unknown_0xe54de3e1': self.unknown_0xe54de3e1,
'unknown_0x8a821fee': self.unknown_0x8a821fee,
}
def _decode_bite_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown_0x200f67e7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe54de3e1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8a821fee(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]]] = {
0xdf636c4b: ('bite_damage', _decode_bite_damage),
0x200f67e7: ('unknown_0x200f67e7', _decode_unknown_0x200f67e7),
0xe54de3e1: ('unknown_0xe54de3e1', _decode_unknown_0xe54de3e1),
0x8a821fee: ('unknown_0x8a821fee', _decode_unknown_0x8a821fee),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/KorbaMawData.py | 0.606732 | 0.260231 | KorbaMawData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class RagDollData(BaseProperty):
gravity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=-50.0))
rag_doll_density: float = dataclasses.field(default=8000.0)
air_density: float = dataclasses.field(default=1.2000000476837158)
fluid_gravity: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=-3.0))
fluid_density: float = dataclasses.field(default=1000.0)
restitution_multiplier: float = dataclasses.field(default=0.125)
friction_multiplier: float = dataclasses.field(default=0.8500000238418579)
unknown_0x91936b5e: float = dataclasses.field(default=1.0)
unknown_0x81d40910: float = dataclasses.field(default=3000.0)
static_speed: float = dataclasses.field(default=0.5)
max_time: float = dataclasses.field(default=5.0)
sound_impact: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xce5d16c3: bool = dataclasses.field(default=False)
damp_rotation: bool = dataclasses.field(default=True)
ignore_max_time: bool = dataclasses.field(default=False)
ignore_dock_collision: bool = dataclasses.field(default=False)
ignore_all_collision: bool = dataclasses.field(default=False)
collision_type: enums.CollisionType = dataclasses.field(default=enums.CollisionType.Unknown3)
collision_plane_normal: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=1.0))
collision_plane_constant: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x14') # 20 properties
data.write(b'\x9e#\\a') # 0x9e235c61
data.write(b'\x00\x0c') # size
self.gravity.to_stream(data)
data.write(b'j\xb04\x1a') # 0x6ab0341a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rag_doll_density))
data.write(b'C\xc0"$') # 0x43c02224
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.air_density))
data.write(b'\xa0B\x1a\xa5') # 0xa0421aa5
data.write(b'\x00\x0c') # size
self.fluid_gravity.to_stream(data)
data.write(b'k\xd4\xe1x') # 0x6bd4e178
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fluid_density))
data.write(b'Dj3\xf5') # 0x446a33f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.restitution_multiplier))
data.write(b'\x08\xb31\xce') # 0x8b331ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.friction_multiplier))
data.write(b'\x91\x93k^') # 0x91936b5e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x91936b5e))
data.write(b'\x81\xd4\t\x10') # 0x81d40910
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x81d40910))
data.write(b'\x16@~\xd9') # 0x16407ed9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.static_speed))
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'\xe1\x90\xf7}') # 0xe190f77d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_impact))
data.write(b'\xce]\x16\xc3') # 0xce5d16c3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xce5d16c3))
data.write(b'\xa9\x9a\x0e3') # 0xa99a0e33
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.damp_rotation))
data.write(b'\xe7\xb8\x8dQ') # 0xe7b88d51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_max_time))
data.write(b'}\xe2\xe6\xba') # 0x7de2e6ba
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_dock_collision))
data.write(b'\xe1\x10|J') # 0xe1107c4a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_all_collision))
data.write(b'\xb6t\xea=') # 0xb674ea3d
data.write(b'\x00\x04') # size
self.collision_type.to_stream(data)
data.write(b'\x96\xbb0*') # 0x96bb302a
data.write(b'\x00\x0c') # size
self.collision_plane_normal.to_stream(data)
data.write(b'D\x14\xd9\x9c') # 0x4414d99c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_plane_constant))
@classmethod
def from_json(cls, data: dict):
return cls(
gravity=Vector.from_json(data['gravity']),
rag_doll_density=data['rag_doll_density'],
air_density=data['air_density'],
fluid_gravity=Vector.from_json(data['fluid_gravity']),
fluid_density=data['fluid_density'],
restitution_multiplier=data['restitution_multiplier'],
friction_multiplier=data['friction_multiplier'],
unknown_0x91936b5e=data['unknown_0x91936b5e'],
unknown_0x81d40910=data['unknown_0x81d40910'],
static_speed=data['static_speed'],
max_time=data['max_time'],
sound_impact=data['sound_impact'],
unknown_0xce5d16c3=data['unknown_0xce5d16c3'],
damp_rotation=data['damp_rotation'],
ignore_max_time=data['ignore_max_time'],
ignore_dock_collision=data['ignore_dock_collision'],
ignore_all_collision=data['ignore_all_collision'],
collision_type=enums.CollisionType.from_json(data['collision_type']),
collision_plane_normal=Vector.from_json(data['collision_plane_normal']),
collision_plane_constant=data['collision_plane_constant'],
)
def to_json(self) -> dict:
return {
'gravity': self.gravity.to_json(),
'rag_doll_density': self.rag_doll_density,
'air_density': self.air_density,
'fluid_gravity': self.fluid_gravity.to_json(),
'fluid_density': self.fluid_density,
'restitution_multiplier': self.restitution_multiplier,
'friction_multiplier': self.friction_multiplier,
'unknown_0x91936b5e': self.unknown_0x91936b5e,
'unknown_0x81d40910': self.unknown_0x81d40910,
'static_speed': self.static_speed,
'max_time': self.max_time,
'sound_impact': self.sound_impact,
'unknown_0xce5d16c3': self.unknown_0xce5d16c3,
'damp_rotation': self.damp_rotation,
'ignore_max_time': self.ignore_max_time,
'ignore_dock_collision': self.ignore_dock_collision,
'ignore_all_collision': self.ignore_all_collision,
'collision_type': self.collision_type.to_json(),
'collision_plane_normal': self.collision_plane_normal.to_json(),
'collision_plane_constant': self.collision_plane_constant,
}
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_rag_doll_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_air_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fluid_gravity(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_fluid_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_restitution_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_friction_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x91936b5e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x81d40910(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_static_speed(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_sound_impact(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xce5d16c3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damp_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_max_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_dock_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_all_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_collision_type(data: typing.BinaryIO, property_size: int):
return enums.CollisionType.from_stream(data)
def _decode_collision_plane_normal(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_plane_constant(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]]] = {
0x9e235c61: ('gravity', _decode_gravity),
0x6ab0341a: ('rag_doll_density', _decode_rag_doll_density),
0x43c02224: ('air_density', _decode_air_density),
0xa0421aa5: ('fluid_gravity', _decode_fluid_gravity),
0x6bd4e178: ('fluid_density', _decode_fluid_density),
0x446a33f5: ('restitution_multiplier', _decode_restitution_multiplier),
0x8b331ce: ('friction_multiplier', _decode_friction_multiplier),
0x91936b5e: ('unknown_0x91936b5e', _decode_unknown_0x91936b5e),
0x81d40910: ('unknown_0x81d40910', _decode_unknown_0x81d40910),
0x16407ed9: ('static_speed', _decode_static_speed),
0x3e7b2b4: ('max_time', _decode_max_time),
0xe190f77d: ('sound_impact', _decode_sound_impact),
0xce5d16c3: ('unknown_0xce5d16c3', _decode_unknown_0xce5d16c3),
0xa99a0e33: ('damp_rotation', _decode_damp_rotation),
0xe7b88d51: ('ignore_max_time', _decode_ignore_max_time),
0x7de2e6ba: ('ignore_dock_collision', _decode_ignore_dock_collision),
0xe1107c4a: ('ignore_all_collision', _decode_ignore_all_collision),
0xb674ea3d: ('collision_type', _decode_collision_type),
0x96bb302a: ('collision_plane_normal', _decode_collision_plane_normal),
0x4414d99c: ('collision_plane_constant', _decode_collision_plane_constant),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/RagDollData.py | 0.571049 | 0.297056 | RagDollData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
@dataclasses.dataclass()
class PhysicsDebrisPropertiesOrientationEnum(BaseProperty):
orientation: enums.UnknownEnum1 = dataclasses.field(default=enums.UnknownEnum1.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\xf4\xbff7') # 0xf4bf6637
data.write(b'\x00\x04') # size
self.orientation.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
orientation=enums.UnknownEnum1.from_json(data['orientation']),
)
def to_json(self) -> dict:
return {
'orientation': self.orientation.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0xf4bf6637)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PhysicsDebrisPropertiesOrientationEnum]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return PhysicsDebrisPropertiesOrientationEnum(
enums.UnknownEnum1(dec[2]),
)
def _decode_orientation(data: typing.BinaryIO, property_size: int):
return enums.UnknownEnum1.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf4bf6637: ('orientation', _decode_orientation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/PhysicsDebrisPropertiesOrientationEnum.py | 0.676727 | 0.267665 | PhysicsDebrisPropertiesOrientationEnum.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct6(BaseProperty):
gravity_buster_chance: float = dataclasses.field(default=35.0)
combat_hatches_chance: float = dataclasses.field(default=25.0)
dark_samus_echoes_chance: float = dataclasses.field(default=15.0)
turret_chance: float = dataclasses.field(default=25.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\xa1D3\xc3') # 0xa14433c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity_buster_chance))
data.write(b'\xaf\xe4\x82\x13') # 0xafe48213
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.combat_hatches_chance))
data.write(b'\x05\xa5\xd4\xd0') # 0x5a5d4d0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dark_samus_echoes_chance))
data.write(b'\xd5x\t\x05') # 0xd5780905
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.turret_chance))
@classmethod
def from_json(cls, data: dict):
return cls(
gravity_buster_chance=data['gravity_buster_chance'],
combat_hatches_chance=data['combat_hatches_chance'],
dark_samus_echoes_chance=data['dark_samus_echoes_chance'],
turret_chance=data['turret_chance'],
)
def to_json(self) -> dict:
return {
'gravity_buster_chance': self.gravity_buster_chance,
'combat_hatches_chance': self.combat_hatches_chance,
'dark_samus_echoes_chance': self.dark_samus_echoes_chance,
'turret_chance': self.turret_chance,
}
_FAST_FORMAT = None
_FAST_IDS = (0xa14433c3, 0xafe48213, 0x5a5d4d0, 0xd5780905)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct6]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct6(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_gravity_buster_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_combat_hatches_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dark_samus_echoes_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_turret_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa14433c3: ('gravity_buster_chance', _decode_gravity_buster_chance),
0xafe48213: ('combat_hatches_chance', _decode_combat_hatches_chance),
0x5a5d4d0: ('dark_samus_echoes_chance', _decode_dark_samus_echoes_chance),
0xd5780905: ('turret_chance', _decode_turret_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct6.py | 0.59749 | 0.281563 | UnknownStruct6.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.Color import Color
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class ModIncaData(BaseProperty):
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)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\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)
@classmethod
def from_json(cls, data: dict):
return cls(
mod_inca_color=Color.from_json(data['mod_inca_color']),
mod_inca_amount=Spline.from_json(data['mod_inca_amount']),
)
def to_json(self) -> dict:
return {
'mod_inca_color': self.mod_inca_color.to_json(),
'mod_inca_amount': self.mod_inca_amount.to_json(),
}
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)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf8df6cd2: ('mod_inca_color', _decode_mod_inca_color),
0xc23011d9: ('mod_inca_amount', _decode_mod_inca_amount),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/ModIncaData.py | 0.640411 | 0.259661 | ModIncaData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class UnknownStruct16(BaseProperty):
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_box_size: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=2.0))
unknown: float = dataclasses.field(default=215.0)
max_length: float = dataclasses.field(default=100.0)
burn_damage: float = dataclasses.field(default=1.0)
burn_duration: float = dataclasses.field(default=5.0)
damage_delay: float = dataclasses.field(default=0.5)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x07') # 7 properties
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data, default_override={'di_damage': 5.0, 'di_knock_back_power': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x866\x86\x13') # 0x86368613
data.write(b'\x00\x0c') # size
self.damage_box_size.to_stream(data)
data.write(b'\xf2\xc3\xfc\x10') # 0xf2c3fc10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x7f0\x92L') # 0x7f30924c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_length))
data.write(b'\xcf \x1b\xfa') # 0xcf201bfa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.burn_damage))
data.write(b'\x88\x13\x7f\xa8') # 0x88137fa8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.burn_duration))
data.write(b'\x8fO\xb7\x9d') # 0x8f4fb79d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_delay))
@classmethod
def from_json(cls, data: dict):
return cls(
damage=DamageInfo.from_json(data['damage']),
damage_box_size=Vector.from_json(data['damage_box_size']),
unknown=data['unknown'],
max_length=data['max_length'],
burn_damage=data['burn_damage'],
burn_duration=data['burn_duration'],
damage_delay=data['damage_delay'],
)
def to_json(self) -> dict:
return {
'damage': self.damage.to_json(),
'damage_box_size': self.damage_box_size.to_json(),
'unknown': self.unknown,
'max_length': self.max_length,
'burn_damage': self.burn_damage,
'burn_duration': self.burn_duration,
'damage_delay': self.damage_delay,
}
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_damage': 5.0, 'di_knock_back_power': 10.0})
def _decode_damage_box_size(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_burn_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_burn_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x337f9524: ('damage', _decode_damage),
0x86368613: ('damage_box_size', _decode_damage_box_size),
0xf2c3fc10: ('unknown', _decode_unknown),
0x7f30924c: ('max_length', _decode_max_length),
0xcf201bfa: ('burn_damage', _decode_burn_damage),
0x88137fa8: ('burn_duration', _decode_burn_duration),
0x8f4fb79d: ('damage_delay', _decode_damage_delay),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct16.py | 0.623377 | 0.286893 | UnknownStruct16.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.FlyerMovementMode import FlyerMovementMode
from retro_data_structures.properties.corruption.archetypes.GrappleData import GrappleData
from retro_data_structures.properties.corruption.archetypes.LaunchProjectileData import LaunchProjectileData
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct61(BaseProperty):
patrol: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
attack: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
missile_deflection_radius: float = dataclasses.field(default=20.0)
missile_deflection_rate: float = dataclasses.field(default=120.0)
unknown_0x8ac503de: int = dataclasses.field(default=3)
shot_prediction: float = dataclasses.field(default=0.699999988079071)
close_enough_distance: float = dataclasses.field(default=15.0)
minimum_firing_distance: float = dataclasses.field(default=10.0)
maximum_firing_distance: float = dataclasses.field(default=25.0)
recheck_path_distance: float = dataclasses.field(default=5.0)
update_path_time: float = dataclasses.field(default=3.0)
unknown_0x271e49b4: float = dataclasses.field(default=1.0)
projectile_left: LaunchProjectileData = dataclasses.field(default_factory=LaunchProjectileData)
projectile_right: LaunchProjectileData = dataclasses.field(default_factory=LaunchProjectileData)
reload_delay: float = dataclasses.field(default=2.0)
shot_delay: float = dataclasses.field(default=2.0)
unknown_0x04d03b18: float = dataclasses.field(default=2.0)
grapple_data: GrappleData = dataclasses.field(default_factory=GrappleData)
dodge_chance_after_fire: int = dataclasses.field(default=25)
dodge_chance_after_reload: int = dataclasses.field(default=25)
unknown_0xd88ecc2f: int = dataclasses.field(default=25)
unknown_0x50b47d78: int = dataclasses.field(default=25)
dodge_chance_after_taunt: int = dataclasses.field(default=25)
unknown_0xd7c5c618: float = dataclasses.field(default=5.0)
unknown_0x0c7a95ff: float = dataclasses.field(default=25.0)
char: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1b') # 27 properties
data.write(b'\xcc\xdd:\xca') # 0xccdd3aca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patrol.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa*\x17?') # 0xfa2a173f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c[`\xaa') # 0x635b60aa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.part))
data.write(b'\x88\xfa*\xcf') # 0x88fa2acf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.missile_deflection_radius))
data.write(b'\x1d\x15\x982') # 0x1d159832
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.missile_deflection_rate))
data.write(b'\x8a\xc5\x03\xde') # 0x8ac503de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x8ac503de))
data.write(b'\x18t\xf2\xcb') # 0x1874f2cb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shot_prediction))
data.write(b'$\x93p\x85') # 0x24937085
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.close_enough_distance))
data.write(b'\xcaR8\xbf') # 0xca5238bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_firing_distance))
data.write(b')\x0f\x86e') # 0x290f8665
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_firing_distance))
data.write(b'v&\xec\x89') # 0x7626ec89
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.recheck_path_distance))
data.write(b'\xf4\xb6\tQ') # 0xf4b60951
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.update_path_time))
data.write(b"'\x1eI\xb4") # 0x271e49b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x271e49b4))
data.write(b'r\x98\x95G') # 0x72989547
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_left.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S\xea\xc4\xba') # 0x53eac4ba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_right.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\xdf\x12b') # 0xf9df1262
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.reload_delay))
data.write(b'=i\xd7P') # 0x3d69d750
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shot_delay))
data.write(b'\x04\xd0;\x18') # 0x4d03b18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x04d03b18))
data.write(b'\xf6\t\xc67') # 0xf609c637
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grapple_data.to_stream(data, default_override={'grapple_type': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9a\xb0\xa9\x87') # 0x9ab0a987
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.dodge_chance_after_fire))
data.write(b'\x0c\x14%=') # 0xc14253d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.dodge_chance_after_reload))
data.write(b'\xd8\x8e\xcc/') # 0xd88ecc2f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd88ecc2f))
data.write(b'P\xb4}x') # 0x50b47d78
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x50b47d78))
data.write(b'T\x9b\t\x8b') # 0x549b098b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.dodge_chance_after_taunt))
data.write(b'\xd7\xc5\xc6\x18') # 0xd7c5c618
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd7c5c618))
data.write(b'\x0cz\x95\xff') # 0xc7a95ff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0c7a95ff))
data.write(b'\xd8;\x83\x02') # 0xd83b8302
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
patrol=FlyerMovementMode.from_json(data['patrol']),
attack=FlyerMovementMode.from_json(data['attack']),
part=data['part'],
missile_deflection_radius=data['missile_deflection_radius'],
missile_deflection_rate=data['missile_deflection_rate'],
unknown_0x8ac503de=data['unknown_0x8ac503de'],
shot_prediction=data['shot_prediction'],
close_enough_distance=data['close_enough_distance'],
minimum_firing_distance=data['minimum_firing_distance'],
maximum_firing_distance=data['maximum_firing_distance'],
recheck_path_distance=data['recheck_path_distance'],
update_path_time=data['update_path_time'],
unknown_0x271e49b4=data['unknown_0x271e49b4'],
projectile_left=LaunchProjectileData.from_json(data['projectile_left']),
projectile_right=LaunchProjectileData.from_json(data['projectile_right']),
reload_delay=data['reload_delay'],
shot_delay=data['shot_delay'],
unknown_0x04d03b18=data['unknown_0x04d03b18'],
grapple_data=GrappleData.from_json(data['grapple_data']),
dodge_chance_after_fire=data['dodge_chance_after_fire'],
dodge_chance_after_reload=data['dodge_chance_after_reload'],
unknown_0xd88ecc2f=data['unknown_0xd88ecc2f'],
unknown_0x50b47d78=data['unknown_0x50b47d78'],
dodge_chance_after_taunt=data['dodge_chance_after_taunt'],
unknown_0xd7c5c618=data['unknown_0xd7c5c618'],
unknown_0x0c7a95ff=data['unknown_0x0c7a95ff'],
char=AnimationParameters.from_json(data['char']),
)
def to_json(self) -> dict:
return {
'patrol': self.patrol.to_json(),
'attack': self.attack.to_json(),
'part': self.part,
'missile_deflection_radius': self.missile_deflection_radius,
'missile_deflection_rate': self.missile_deflection_rate,
'unknown_0x8ac503de': self.unknown_0x8ac503de,
'shot_prediction': self.shot_prediction,
'close_enough_distance': self.close_enough_distance,
'minimum_firing_distance': self.minimum_firing_distance,
'maximum_firing_distance': self.maximum_firing_distance,
'recheck_path_distance': self.recheck_path_distance,
'update_path_time': self.update_path_time,
'unknown_0x271e49b4': self.unknown_0x271e49b4,
'projectile_left': self.projectile_left.to_json(),
'projectile_right': self.projectile_right.to_json(),
'reload_delay': self.reload_delay,
'shot_delay': self.shot_delay,
'unknown_0x04d03b18': self.unknown_0x04d03b18,
'grapple_data': self.grapple_data.to_json(),
'dodge_chance_after_fire': self.dodge_chance_after_fire,
'dodge_chance_after_reload': self.dodge_chance_after_reload,
'unknown_0xd88ecc2f': self.unknown_0xd88ecc2f,
'unknown_0x50b47d78': self.unknown_0x50b47d78,
'dodge_chance_after_taunt': self.dodge_chance_after_taunt,
'unknown_0xd7c5c618': self.unknown_0xd7c5c618,
'unknown_0x0c7a95ff': self.unknown_0x0c7a95ff,
'char': self.char.to_json(),
}
def _decode_patrol(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_attack(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_missile_deflection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_missile_deflection_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8ac503de(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_shot_prediction(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_close_enough_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_firing_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_firing_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_recheck_path_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_update_path_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x271e49b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_left(data: typing.BinaryIO, property_size: int):
return LaunchProjectileData.from_stream(data, property_size)
def _decode_projectile_right(data: typing.BinaryIO, property_size: int):
return LaunchProjectileData.from_stream(data, property_size)
def _decode_reload_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shot_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x04d03b18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grapple_data(data: typing.BinaryIO, property_size: int):
return GrappleData.from_stream(data, property_size, default_override={'grapple_type': 1})
def _decode_dodge_chance_after_fire(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dodge_chance_after_reload(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd88ecc2f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x50b47d78(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dodge_chance_after_taunt(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd7c5c618(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0c7a95ff(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_char(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xccdd3aca: ('patrol', _decode_patrol),
0xfa2a173f: ('attack', _decode_attack),
0x635b60aa: ('part', _decode_part),
0x88fa2acf: ('missile_deflection_radius', _decode_missile_deflection_radius),
0x1d159832: ('missile_deflection_rate', _decode_missile_deflection_rate),
0x8ac503de: ('unknown_0x8ac503de', _decode_unknown_0x8ac503de),
0x1874f2cb: ('shot_prediction', _decode_shot_prediction),
0x24937085: ('close_enough_distance', _decode_close_enough_distance),
0xca5238bf: ('minimum_firing_distance', _decode_minimum_firing_distance),
0x290f8665: ('maximum_firing_distance', _decode_maximum_firing_distance),
0x7626ec89: ('recheck_path_distance', _decode_recheck_path_distance),
0xf4b60951: ('update_path_time', _decode_update_path_time),
0x271e49b4: ('unknown_0x271e49b4', _decode_unknown_0x271e49b4),
0x72989547: ('projectile_left', _decode_projectile_left),
0x53eac4ba: ('projectile_right', _decode_projectile_right),
0xf9df1262: ('reload_delay', _decode_reload_delay),
0x3d69d750: ('shot_delay', _decode_shot_delay),
0x4d03b18: ('unknown_0x04d03b18', _decode_unknown_0x04d03b18),
0xf609c637: ('grapple_data', _decode_grapple_data),
0x9ab0a987: ('dodge_chance_after_fire', _decode_dodge_chance_after_fire),
0xc14253d: ('dodge_chance_after_reload', _decode_dodge_chance_after_reload),
0xd88ecc2f: ('unknown_0xd88ecc2f', _decode_unknown_0xd88ecc2f),
0x50b47d78: ('unknown_0x50b47d78', _decode_unknown_0x50b47d78),
0x549b098b: ('dodge_chance_after_taunt', _decode_dodge_chance_after_taunt),
0xd7c5c618: ('unknown_0xd7c5c618', _decode_unknown_0xd7c5c618),
0xc7a95ff: ('unknown_0x0c7a95ff', _decode_unknown_0x0c7a95ff),
0xd83b8302: ('char', _decode_char),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct61.py | 0.61115 | 0.199776 | UnknownStruct61.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class HyperMode(BaseProperty):
hyper_mode_tank: bool = dataclasses.field(default=False)
hyper_mode_beam: bool = dataclasses.field(default=False)
hyper_mode_grapple: bool = dataclasses.field(default=False)
hyper_mode_missile: bool = dataclasses.field(default=False)
hyper_mode_ball: bool = dataclasses.field(default=False)
hyper_mode_permanent: bool = dataclasses.field(default=False)
hyper_mode_phaaze: bool = dataclasses.field(default=False)
hyper_mode_original: bool = dataclasses.field(default=False)
hyper_mode_charge: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\xac\xbd\xa4\\') # 0xacbda45c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_tank))
data.write(b'\x9c0\xff\x96') # 0x9c30ff96
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_beam))
data.write(b'&\xa8]\xf4') # 0x26a85df4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_grapple))
data.write(b'\xe5\xb6\xcbf') # 0xe5b6cb66
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_missile))
data.write(b'\xe9\x81\xe1\xeb') # 0xe981e1eb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_ball))
data.write(b'\xfe\x9b(\x03') # 0xfe9b2803
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_permanent))
data.write(b'\xec\xd5&\x1f') # 0xecd5261f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_phaaze))
data.write(b'*\x05\xe6\xd9') # 0x2a05e6d9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_original))
data.write(b'\xc92\x8b\xe2') # 0xc9328be2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hyper_mode_charge))
@classmethod
def from_json(cls, data: dict):
return cls(
hyper_mode_tank=data['hyper_mode_tank'],
hyper_mode_beam=data['hyper_mode_beam'],
hyper_mode_grapple=data['hyper_mode_grapple'],
hyper_mode_missile=data['hyper_mode_missile'],
hyper_mode_ball=data['hyper_mode_ball'],
hyper_mode_permanent=data['hyper_mode_permanent'],
hyper_mode_phaaze=data['hyper_mode_phaaze'],
hyper_mode_original=data['hyper_mode_original'],
hyper_mode_charge=data['hyper_mode_charge'],
)
def to_json(self) -> dict:
return {
'hyper_mode_tank': self.hyper_mode_tank,
'hyper_mode_beam': self.hyper_mode_beam,
'hyper_mode_grapple': self.hyper_mode_grapple,
'hyper_mode_missile': self.hyper_mode_missile,
'hyper_mode_ball': self.hyper_mode_ball,
'hyper_mode_permanent': self.hyper_mode_permanent,
'hyper_mode_phaaze': self.hyper_mode_phaaze,
'hyper_mode_original': self.hyper_mode_original,
'hyper_mode_charge': self.hyper_mode_charge,
}
_FAST_FORMAT = None
_FAST_IDS = (0xacbda45c, 0x9c30ff96, 0x26a85df4, 0xe5b6cb66, 0xe981e1eb, 0xfe9b2803, 0xecd5261f, 0x2a05e6d9, 0xc9328be2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HyperMode]:
if property_count != 9:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LH?LH?LH?LH?LH?LH?LH?LH?LH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(63))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24]) != _FAST_IDS:
data.seek(before)
return None
return HyperMode(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
)
def _decode_hyper_mode_tank(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_beam(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_grapple(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_missile(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_ball(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_permanent(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_phaaze(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_original(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hyper_mode_charge(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]]] = {
0xacbda45c: ('hyper_mode_tank', _decode_hyper_mode_tank),
0x9c30ff96: ('hyper_mode_beam', _decode_hyper_mode_beam),
0x26a85df4: ('hyper_mode_grapple', _decode_hyper_mode_grapple),
0xe5b6cb66: ('hyper_mode_missile', _decode_hyper_mode_missile),
0xe981e1eb: ('hyper_mode_ball', _decode_hyper_mode_ball),
0xfe9b2803: ('hyper_mode_permanent', _decode_hyper_mode_permanent),
0xecd5261f: ('hyper_mode_phaaze', _decode_hyper_mode_phaaze),
0x2a05e6d9: ('hyper_mode_original', _decode_hyper_mode_original),
0xc9328be2: ('hyper_mode_charge', _decode_hyper_mode_charge),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/HyperMode.py | 0.630571 | 0.244814 | HyperMode.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
@dataclasses.dataclass()
class KorakkData(BaseProperty):
unknown_0x27b15c35: float = dataclasses.field(default=1.0)
unknown_0x6c6b5700: int = dataclasses.field(default=4)
mouth_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
tongue_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
morphball_bite_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info_0x77941011: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info_0x4d07f7b1: DamageInfo = dataclasses.field(default_factory=DamageInfo)
phazon_lance_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_info_0x8333b35f: DamageInfo = dataclasses.field(default_factory=DamageInfo)
stab_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\n') # 10 properties
data.write(b"'\xb1\\5") # 0x27b15c35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x27b15c35))
data.write(b'lkW\x00') # 0x6c6b5700
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6c6b5700))
data.write(b'\xed~\xdc\xa3') # 0xed7edca3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mouth_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xda^\x960') # 0xda5e9630
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.tongue_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'P\x8fqw') # 0x508f7177
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.morphball_bite_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\x94\x10\x11') # 0x77941011
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x77941011.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'M\x07\xf7\xb1') # 0x4d07f7b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x4d07f7b1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\xa2\x12\x1d') # 0x21a2121d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phazon_lance_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x833\xb3_') # 0x8333b35f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x8333b35f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x94`\x16\xa9') # 0x946016a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.stab_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x27b15c35=data['unknown_0x27b15c35'],
unknown_0x6c6b5700=data['unknown_0x6c6b5700'],
mouth_vulnerability=DamageVulnerability.from_json(data['mouth_vulnerability']),
tongue_damage=DamageInfo.from_json(data['tongue_damage']),
morphball_bite_damage=DamageInfo.from_json(data['morphball_bite_damage']),
damage_info_0x77941011=DamageInfo.from_json(data['damage_info_0x77941011']),
damage_info_0x4d07f7b1=DamageInfo.from_json(data['damage_info_0x4d07f7b1']),
phazon_lance_damage=DamageInfo.from_json(data['phazon_lance_damage']),
damage_info_0x8333b35f=DamageInfo.from_json(data['damage_info_0x8333b35f']),
stab_damage=DamageInfo.from_json(data['stab_damage']),
)
def to_json(self) -> dict:
return {
'unknown_0x27b15c35': self.unknown_0x27b15c35,
'unknown_0x6c6b5700': self.unknown_0x6c6b5700,
'mouth_vulnerability': self.mouth_vulnerability.to_json(),
'tongue_damage': self.tongue_damage.to_json(),
'morphball_bite_damage': self.morphball_bite_damage.to_json(),
'damage_info_0x77941011': self.damage_info_0x77941011.to_json(),
'damage_info_0x4d07f7b1': self.damage_info_0x4d07f7b1.to_json(),
'phazon_lance_damage': self.phazon_lance_damage.to_json(),
'damage_info_0x8333b35f': self.damage_info_0x8333b35f.to_json(),
'stab_damage': self.stab_damage.to_json(),
}
def _decode_unknown_0x27b15c35(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6c6b5700(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mouth_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_tongue_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_morphball_bite_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_damage_info_0x77941011(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_damage_info_0x4d07f7b1(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_phazon_lance_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_damage_info_0x8333b35f(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_stab_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x27b15c35: ('unknown_0x27b15c35', _decode_unknown_0x27b15c35),
0x6c6b5700: ('unknown_0x6c6b5700', _decode_unknown_0x6c6b5700),
0xed7edca3: ('mouth_vulnerability', _decode_mouth_vulnerability),
0xda5e9630: ('tongue_damage', _decode_tongue_damage),
0x508f7177: ('morphball_bite_damage', _decode_morphball_bite_damage),
0x77941011: ('damage_info_0x77941011', _decode_damage_info_0x77941011),
0x4d07f7b1: ('damage_info_0x4d07f7b1', _decode_damage_info_0x4d07f7b1),
0x21a2121d: ('phazon_lance_damage', _decode_phazon_lance_damage),
0x8333b35f: ('damage_info_0x8333b35f', _decode_damage_info_0x8333b35f),
0x946016a9: ('stab_damage', _decode_stab_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/KorakkData.py | 0.522446 | 0.283999 | KorakkData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.MultiModelActorStruct import MultiModelActorStruct
@dataclasses.dataclass()
class MultiModelInformation(BaseProperty):
unknown: int = dataclasses.field(default=0)
use_fade: bool = dataclasses.field(default=False)
fade_time: float = dataclasses.field(default=0.0)
multi_model_actor_struct_0x681c4457: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0xc674d5c6: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x3b8d2db3: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x95e5bc22: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0xbc2d08d0: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x12459941: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x9caffe7b: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x32c76fea: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
multi_model_actor_struct_0x681aaa77: MultiModelActorStruct = dataclasses.field(default_factory=MultiModelActorStruct)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'd9\xf4\x87') # 0x6439f487
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\xe2Z\x15\xc1') # 0xe25a15c1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_fade))
data.write(b'\xd4\x12LL') # 0xd4124c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_time))
data.write(b'h\x1cDW') # 0x681c4457
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x681c4457.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6t\xd5\xc6') # 0xc674d5c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0xc674d5c6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b';\x8d-\xb3') # 0x3b8d2db3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x3b8d2db3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xe5\xbc"') # 0x95e5bc22
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x95e5bc22.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc-\x08\xd0') # 0xbc2d08d0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0xbc2d08d0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12E\x99A') # 0x12459941
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x12459941.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9c\xaf\xfe{') # 0x9caffe7b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x9caffe7b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'2\xc7o\xea') # 0x32c76fea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x32c76fea.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h\x1a\xaaw') # 0x681aaa77
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_actor_struct_0x681aaa77.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown=data['unknown'],
use_fade=data['use_fade'],
fade_time=data['fade_time'],
multi_model_actor_struct_0x681c4457=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x681c4457']),
multi_model_actor_struct_0xc674d5c6=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0xc674d5c6']),
multi_model_actor_struct_0x3b8d2db3=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x3b8d2db3']),
multi_model_actor_struct_0x95e5bc22=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x95e5bc22']),
multi_model_actor_struct_0xbc2d08d0=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0xbc2d08d0']),
multi_model_actor_struct_0x12459941=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x12459941']),
multi_model_actor_struct_0x9caffe7b=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x9caffe7b']),
multi_model_actor_struct_0x32c76fea=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x32c76fea']),
multi_model_actor_struct_0x681aaa77=MultiModelActorStruct.from_json(data['multi_model_actor_struct_0x681aaa77']),
)
def to_json(self) -> dict:
return {
'unknown': self.unknown,
'use_fade': self.use_fade,
'fade_time': self.fade_time,
'multi_model_actor_struct_0x681c4457': self.multi_model_actor_struct_0x681c4457.to_json(),
'multi_model_actor_struct_0xc674d5c6': self.multi_model_actor_struct_0xc674d5c6.to_json(),
'multi_model_actor_struct_0x3b8d2db3': self.multi_model_actor_struct_0x3b8d2db3.to_json(),
'multi_model_actor_struct_0x95e5bc22': self.multi_model_actor_struct_0x95e5bc22.to_json(),
'multi_model_actor_struct_0xbc2d08d0': self.multi_model_actor_struct_0xbc2d08d0.to_json(),
'multi_model_actor_struct_0x12459941': self.multi_model_actor_struct_0x12459941.to_json(),
'multi_model_actor_struct_0x9caffe7b': self.multi_model_actor_struct_0x9caffe7b.to_json(),
'multi_model_actor_struct_0x32c76fea': self.multi_model_actor_struct_0x32c76fea.to_json(),
'multi_model_actor_struct_0x681aaa77': self.multi_model_actor_struct_0x681aaa77.to_json(),
}
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_use_fade(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_multi_model_actor_struct_0x681c4457(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0xc674d5c6(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x3b8d2db3(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x95e5bc22(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0xbc2d08d0(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x12459941(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x9caffe7b(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x32c76fea(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
def _decode_multi_model_actor_struct_0x681aaa77(data: typing.BinaryIO, property_size: int):
return MultiModelActorStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x6439f487: ('unknown', _decode_unknown),
0xe25a15c1: ('use_fade', _decode_use_fade),
0xd4124c4c: ('fade_time', _decode_fade_time),
0x681c4457: ('multi_model_actor_struct_0x681c4457', _decode_multi_model_actor_struct_0x681c4457),
0xc674d5c6: ('multi_model_actor_struct_0xc674d5c6', _decode_multi_model_actor_struct_0xc674d5c6),
0x3b8d2db3: ('multi_model_actor_struct_0x3b8d2db3', _decode_multi_model_actor_struct_0x3b8d2db3),
0x95e5bc22: ('multi_model_actor_struct_0x95e5bc22', _decode_multi_model_actor_struct_0x95e5bc22),
0xbc2d08d0: ('multi_model_actor_struct_0xbc2d08d0', _decode_multi_model_actor_struct_0xbc2d08d0),
0x12459941: ('multi_model_actor_struct_0x12459941', _decode_multi_model_actor_struct_0x12459941),
0x9caffe7b: ('multi_model_actor_struct_0x9caffe7b', _decode_multi_model_actor_struct_0x9caffe7b),
0x32c76fea: ('multi_model_actor_struct_0x32c76fea', _decode_multi_model_actor_struct_0x32c76fea),
0x681aaa77: ('multi_model_actor_struct_0x681aaa77', _decode_multi_model_actor_struct_0x681aaa77),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/MultiModelInformation.py | 0.489015 | 0.18628 | MultiModelInformation.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MultiModelActorStruct(BaseProperty):
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
fade_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\xd4\x12LL') # 0xd4124c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_time))
@classmethod
def from_json(cls, data: dict):
return cls(
model=data['model'],
fade_time=data['fade_time'],
)
def to_json(self) -> dict:
return {
'model': self.model,
'fade_time': self.fade_time,
}
_FAST_FORMAT = None
_FAST_IDS = (0xc27ffa8f, 0xd4124c4c)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MultiModelActorStruct]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHQLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(24))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return MultiModelActorStruct(
dec[2],
dec[5],
)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_fade_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]]] = {
0xc27ffa8f: ('model', _decode_model),
0xd4124c4c: ('fade_time', _decode_fade_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/MultiModelActorStruct.py | 0.61451 | 0.224757 | MultiModelActorStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.TDamageInfo import TDamageInfo
@dataclasses.dataclass()
class TWeaponDamage(BaseProperty):
normal: TDamageInfo = dataclasses.field(default_factory=TDamageInfo)
charged: TDamageInfo = dataclasses.field(default_factory=TDamageInfo)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b"\x8a\xc4'\x8a") # 0x8ac4278a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.normal.to_stream(data, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9\xac\x01\xd2') # 0xc9ac01d2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.charged.to_stream(data, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
normal=TDamageInfo.from_json(data['normal']),
charged=TDamageInfo.from_json(data['charged']),
)
def to_json(self) -> dict:
return {
'normal': self.normal.to_json(),
'charged': self.charged.to_json(),
}
def _decode_normal(data: typing.BinaryIO, property_size: int):
return TDamageInfo.from_stream(data, property_size, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
def _decode_charged(data: typing.BinaryIO, property_size: int):
return TDamageInfo.from_stream(data, property_size, default_override={'damage_amount': 50.0, 'radius_damage_amount': 25.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x8ac4278a: ('normal', _decode_normal),
0xc9ac01d2: ('charged', _decode_charged),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/TWeaponDamage.py | 0.592549 | 0.299208 | TWeaponDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class EnergyWhip(BaseProperty):
animation_info: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
hyper_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x894c2b5d: float = dataclasses.field(default=2.5)
max_attack_dist: float = dataclasses.field(default=15.0)
world_impact_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
player_impact_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xde12b1d5: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\\\x1f\xfc\x8d') # 0x5c1ffc8d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_info.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'\xb3\xda\xbf\x84') # 0xb3dabf84
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.hyper_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89L+]') # 0x894c2b5d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x894c2b5d))
data.write(b'.\xd2_P') # 0x2ed25f50
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_dist))
data.write(b'\xb1T\xf3\xfd') # 0xb154f3fd
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.world_impact_effect))
data.write(b'\xe3:\x99m') # 0xe33a996d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.player_impact_sound))
data.write(b'\xde\x12\xb1\xd5') # 0xde12b1d5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xde12b1d5))
@classmethod
def from_json(cls, data: dict):
return cls(
animation_info=AnimationParameters.from_json(data['animation_info']),
damage=DamageInfo.from_json(data['damage']),
hyper_damage=DamageInfo.from_json(data['hyper_damage']),
unknown_0x894c2b5d=data['unknown_0x894c2b5d'],
max_attack_dist=data['max_attack_dist'],
world_impact_effect=data['world_impact_effect'],
player_impact_sound=data['player_impact_sound'],
unknown_0xde12b1d5=data['unknown_0xde12b1d5'],
)
def to_json(self) -> dict:
return {
'animation_info': self.animation_info.to_json(),
'damage': self.damage.to_json(),
'hyper_damage': self.hyper_damage.to_json(),
'unknown_0x894c2b5d': self.unknown_0x894c2b5d,
'max_attack_dist': self.max_attack_dist,
'world_impact_effect': self.world_impact_effect,
'player_impact_sound': self.player_impact_sound,
'unknown_0xde12b1d5': self.unknown_0xde12b1d5,
}
def _decode_animation_info(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_hyper_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown_0x894c2b5d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_dist(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_world_impact_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_player_impact_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xde12b1d5(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]]] = {
0x5c1ffc8d: ('animation_info', _decode_animation_info),
0x337f9524: ('damage', _decode_damage),
0xb3dabf84: ('hyper_damage', _decode_hyper_damage),
0x894c2b5d: ('unknown_0x894c2b5d', _decode_unknown_0x894c2b5d),
0x2ed25f50: ('max_attack_dist', _decode_max_attack_dist),
0xb154f3fd: ('world_impact_effect', _decode_world_impact_effect),
0xe33a996d: ('player_impact_sound', _decode_player_impact_sound),
0xde12b1d5: ('unknown_0xde12b1d5', _decode_unknown_0xde12b1d5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/EnergyWhip.py | 0.632389 | 0.24907 | EnergyWhip.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.UnknownStruct18 import UnknownStruct18
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class UnknownStruct19(BaseProperty):
health: float = dataclasses.field(default=750.0)
animation_speed: float = dataclasses.field(default=1.0499999523162842)
body_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
mouth_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
joint_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
orb_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
stun_threshold: float = dataclasses.field(default=80.0)
stun_decay: float = dataclasses.field(default=0.0)
wander_distance: float = dataclasses.field(default=25.0)
too_far_distance: float = dataclasses.field(default=40.0)
dash_delay_maximum: float = dataclasses.field(default=18.0)
dash_delay_minimum: float = dataclasses.field(default=15.0)
dash_delay_variance: float = dataclasses.field(default=3.0)
unknown_0x673a2724: float = dataclasses.field(default=24.0)
unknown_0x815a88c5: float = dataclasses.field(default=16.0)
stun_delay_max: float = dataclasses.field(default=12.0)
stun_delay_min: float = dataclasses.field(default=8.0)
unknown_0x86e154b4: float = dataclasses.field(default=15.0)
unknown_0x20dc1c96: float = dataclasses.field(default=0.0)
unknown_0xfba7c57b: float = dataclasses.field(default=0.009999999776482582)
unknown_0xba801f2f: float = dataclasses.field(default=1.0)
unknown_0xe1ee4260: float = dataclasses.field(default=1.0)
unknown_0x8e080314: float = dataclasses.field(default=50.0)
unknown_0xd7d24bfa: int = dataclasses.field(default=3)
unknown_struct18: UnknownStruct18 = dataclasses.field(default_factory=UnknownStruct18)
unknown_0xa62404dc: float = dataclasses.field(default=0.10000000149011612)
unknown_0xbf8b57bf: float = dataclasses.field(default=1.0)
unknown_0x530ecf07: float = dataclasses.field(default=2.0)
unknown_0x8482e270: float = dataclasses.field(default=1.5)
unknown_0x7128f60e: float = dataclasses.field(default=0.30000001192092896)
unknown_0xd9c4aa53: str = dataclasses.field(default='')
left_target_attachment: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0x71c8e644: str = dataclasses.field(default='')
unknown_0x8cb60fc9: str = dataclasses.field(default='')
right_target_attachment: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0x967948b7: str = dataclasses.field(default='')
left_armor_attachment: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0xf5ed7ba0: str = dataclasses.field(default='')
right_armor_attachment: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0xfc6e8fae: str = dataclasses.field(default='')
cmdl: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0x448d4f01: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00*') # 42 properties
data.write(b'\xf0f\x89\x19') # 0xf0668919
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.health))
data.write(b'\xc5@wW') # 0xc5407757
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.animation_speed))
data.write(b'\r\x920\xd1') # 0xd9230d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.body_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed~\xdc\xa3') # 0xed7edca3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mouth_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b')\\\xf6\t') # 0x295cf609
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.joint_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#\xdd\xbbU') # 0x23ddbb55
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orb_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'[\xdd\x1eL') # 0x5bdd1e4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_threshold))
data.write(b'`\x82C\x0f') # 0x6082430f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_decay))
data.write(b"\xaf'\x0c\x93") # 0xaf270c93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wander_distance))
data.write(b'\x88\x19h\x8d') # 0x8819688d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.too_far_distance))
data.write(b'\x1b7\xed\xa7') # 0x1b37eda7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dash_delay_maximum))
data.write(b'\x8bD\xfdM') # 0x8b44fd4d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dash_delay_minimum))
data.write(b'\xda\xc0^\xb5') # 0xdac05eb5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dash_delay_variance))
data.write(b"g:'$") # 0x673a2724
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x673a2724))
data.write(b'\x81Z\x88\xc5') # 0x815a88c5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x815a88c5))
data.write(b'\xd4\xd6\xa0\x0c') # 0xd4d6a00c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_delay_max))
data.write(b'2\xb6\x0f\xed') # 0x32b60fed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_delay_min))
data.write(b'\x86\xe1T\xb4') # 0x86e154b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x86e154b4))
data.write(b' \xdc\x1c\x96') # 0x20dc1c96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x20dc1c96))
data.write(b'\xfb\xa7\xc5{') # 0xfba7c57b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfba7c57b))
data.write(b'\xba\x80\x1f/') # 0xba801f2f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xba801f2f))
data.write(b'\xe1\xeeB`') # 0xe1ee4260
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe1ee4260))
data.write(b'\x8e\x08\x03\x14') # 0x8e080314
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8e080314))
data.write(b'\xd7\xd2K\xfa') # 0xd7d24bfa
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd7d24bfa))
data.write(b'\xcc\xcc\xa9~') # 0xcccca97e
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'\xa6$\x04\xdc') # 0xa62404dc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa62404dc))
data.write(b'\xbf\x8bW\xbf') # 0xbf8b57bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbf8b57bf))
data.write(b'S\x0e\xcf\x07') # 0x530ecf07
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x530ecf07))
data.write(b'\x84\x82\xe2p') # 0x8482e270
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8482e270))
data.write(b'q(\xf6\x0e') # 0x7128f60e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7128f60e))
data.write(b'\xd9\xc4\xaaS') # 0xd9c4aa53
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xd9c4aa53.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'\x8e\x13\xf1\xf6') # 0x8e13f1f6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_target_attachment))
data.write(b'q\xc8\xe6D') # 0x71c8e644
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x71c8e644.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'\x8c\xb6\x0f\xc9') # 0x8cb60fc9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x8cb60fc9.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'i\xa2_\x05') # 0x69a25f05
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_target_attachment))
data.write(b'\x96yH\xb7') # 0x967948b7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x967948b7.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'\n6l\x12') # 0xa366c12
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_armor_attachment))
data.write(b'\xf5\xed{\xa0') # 0xf5ed7ba0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xf5ed7ba0.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'\x03\xb5\x98\x1c') # 0x3b5981c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_armor_attachment))
data.write(b'\xfcn\x8f\xae') # 0xfc6e8fae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xfc6e8fae.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'\xbbVX\xb3') # 0xbb5658b3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cmdl))
data.write(b'D\x8dO\x01') # 0x448d4f01
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x448d4f01.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
health=data['health'],
animation_speed=data['animation_speed'],
body_vulnerability=DamageVulnerability.from_json(data['body_vulnerability']),
mouth_vulnerability=DamageVulnerability.from_json(data['mouth_vulnerability']),
joint_vulnerability=DamageVulnerability.from_json(data['joint_vulnerability']),
orb_vulnerability=DamageVulnerability.from_json(data['orb_vulnerability']),
stun_threshold=data['stun_threshold'],
stun_decay=data['stun_decay'],
wander_distance=data['wander_distance'],
too_far_distance=data['too_far_distance'],
dash_delay_maximum=data['dash_delay_maximum'],
dash_delay_minimum=data['dash_delay_minimum'],
dash_delay_variance=data['dash_delay_variance'],
unknown_0x673a2724=data['unknown_0x673a2724'],
unknown_0x815a88c5=data['unknown_0x815a88c5'],
stun_delay_max=data['stun_delay_max'],
stun_delay_min=data['stun_delay_min'],
unknown_0x86e154b4=data['unknown_0x86e154b4'],
unknown_0x20dc1c96=data['unknown_0x20dc1c96'],
unknown_0xfba7c57b=data['unknown_0xfba7c57b'],
unknown_0xba801f2f=data['unknown_0xba801f2f'],
unknown_0xe1ee4260=data['unknown_0xe1ee4260'],
unknown_0x8e080314=data['unknown_0x8e080314'],
unknown_0xd7d24bfa=data['unknown_0xd7d24bfa'],
unknown_struct18=UnknownStruct18.from_json(data['unknown_struct18']),
unknown_0xa62404dc=data['unknown_0xa62404dc'],
unknown_0xbf8b57bf=data['unknown_0xbf8b57bf'],
unknown_0x530ecf07=data['unknown_0x530ecf07'],
unknown_0x8482e270=data['unknown_0x8482e270'],
unknown_0x7128f60e=data['unknown_0x7128f60e'],
unknown_0xd9c4aa53=data['unknown_0xd9c4aa53'],
left_target_attachment=data['left_target_attachment'],
unknown_0x71c8e644=data['unknown_0x71c8e644'],
unknown_0x8cb60fc9=data['unknown_0x8cb60fc9'],
right_target_attachment=data['right_target_attachment'],
unknown_0x967948b7=data['unknown_0x967948b7'],
left_armor_attachment=data['left_armor_attachment'],
unknown_0xf5ed7ba0=data['unknown_0xf5ed7ba0'],
right_armor_attachment=data['right_armor_attachment'],
unknown_0xfc6e8fae=data['unknown_0xfc6e8fae'],
cmdl=data['cmdl'],
unknown_0x448d4f01=data['unknown_0x448d4f01'],
)
def to_json(self) -> dict:
return {
'health': self.health,
'animation_speed': self.animation_speed,
'body_vulnerability': self.body_vulnerability.to_json(),
'mouth_vulnerability': self.mouth_vulnerability.to_json(),
'joint_vulnerability': self.joint_vulnerability.to_json(),
'orb_vulnerability': self.orb_vulnerability.to_json(),
'stun_threshold': self.stun_threshold,
'stun_decay': self.stun_decay,
'wander_distance': self.wander_distance,
'too_far_distance': self.too_far_distance,
'dash_delay_maximum': self.dash_delay_maximum,
'dash_delay_minimum': self.dash_delay_minimum,
'dash_delay_variance': self.dash_delay_variance,
'unknown_0x673a2724': self.unknown_0x673a2724,
'unknown_0x815a88c5': self.unknown_0x815a88c5,
'stun_delay_max': self.stun_delay_max,
'stun_delay_min': self.stun_delay_min,
'unknown_0x86e154b4': self.unknown_0x86e154b4,
'unknown_0x20dc1c96': self.unknown_0x20dc1c96,
'unknown_0xfba7c57b': self.unknown_0xfba7c57b,
'unknown_0xba801f2f': self.unknown_0xba801f2f,
'unknown_0xe1ee4260': self.unknown_0xe1ee4260,
'unknown_0x8e080314': self.unknown_0x8e080314,
'unknown_0xd7d24bfa': self.unknown_0xd7d24bfa,
'unknown_struct18': self.unknown_struct18.to_json(),
'unknown_0xa62404dc': self.unknown_0xa62404dc,
'unknown_0xbf8b57bf': self.unknown_0xbf8b57bf,
'unknown_0x530ecf07': self.unknown_0x530ecf07,
'unknown_0x8482e270': self.unknown_0x8482e270,
'unknown_0x7128f60e': self.unknown_0x7128f60e,
'unknown_0xd9c4aa53': self.unknown_0xd9c4aa53,
'left_target_attachment': self.left_target_attachment,
'unknown_0x71c8e644': self.unknown_0x71c8e644,
'unknown_0x8cb60fc9': self.unknown_0x8cb60fc9,
'right_target_attachment': self.right_target_attachment,
'unknown_0x967948b7': self.unknown_0x967948b7,
'left_armor_attachment': self.left_armor_attachment,
'unknown_0xf5ed7ba0': self.unknown_0xf5ed7ba0,
'right_armor_attachment': self.right_armor_attachment,
'unknown_0xfc6e8fae': self.unknown_0xfc6e8fae,
'cmdl': self.cmdl,
'unknown_0x448d4f01': self.unknown_0x448d4f01,
}
def _decode_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_body_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_mouth_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_joint_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_orb_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_stun_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_decay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wander_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_too_far_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dash_delay_maximum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dash_delay_minimum(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dash_delay_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x673a2724(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x815a88c5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_delay_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_delay_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x86e154b4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x20dc1c96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfba7c57b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xba801f2f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe1ee4260(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8e080314(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd7d24bfa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct18(data: typing.BinaryIO, property_size: int):
return UnknownStruct18.from_stream(data, property_size)
def _decode_unknown_0xa62404dc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbf8b57bf(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x530ecf07(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8482e270(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7128f60e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd9c4aa53(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_left_target_attachment(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x71c8e644(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x8cb60fc9(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_right_target_attachment(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x967948b7(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_left_armor_attachment(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xf5ed7ba0(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_right_armor_attachment(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xfc6e8fae(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_cmdl(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x448d4f01(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xf0668919: ('health', _decode_health),
0xc5407757: ('animation_speed', _decode_animation_speed),
0xd9230d1: ('body_vulnerability', _decode_body_vulnerability),
0xed7edca3: ('mouth_vulnerability', _decode_mouth_vulnerability),
0x295cf609: ('joint_vulnerability', _decode_joint_vulnerability),
0x23ddbb55: ('orb_vulnerability', _decode_orb_vulnerability),
0x5bdd1e4c: ('stun_threshold', _decode_stun_threshold),
0x6082430f: ('stun_decay', _decode_stun_decay),
0xaf270c93: ('wander_distance', _decode_wander_distance),
0x8819688d: ('too_far_distance', _decode_too_far_distance),
0x1b37eda7: ('dash_delay_maximum', _decode_dash_delay_maximum),
0x8b44fd4d: ('dash_delay_minimum', _decode_dash_delay_minimum),
0xdac05eb5: ('dash_delay_variance', _decode_dash_delay_variance),
0x673a2724: ('unknown_0x673a2724', _decode_unknown_0x673a2724),
0x815a88c5: ('unknown_0x815a88c5', _decode_unknown_0x815a88c5),
0xd4d6a00c: ('stun_delay_max', _decode_stun_delay_max),
0x32b60fed: ('stun_delay_min', _decode_stun_delay_min),
0x86e154b4: ('unknown_0x86e154b4', _decode_unknown_0x86e154b4),
0x20dc1c96: ('unknown_0x20dc1c96', _decode_unknown_0x20dc1c96),
0xfba7c57b: ('unknown_0xfba7c57b', _decode_unknown_0xfba7c57b),
0xba801f2f: ('unknown_0xba801f2f', _decode_unknown_0xba801f2f),
0xe1ee4260: ('unknown_0xe1ee4260', _decode_unknown_0xe1ee4260),
0x8e080314: ('unknown_0x8e080314', _decode_unknown_0x8e080314),
0xd7d24bfa: ('unknown_0xd7d24bfa', _decode_unknown_0xd7d24bfa),
0xcccca97e: ('unknown_struct18', _decode_unknown_struct18),
0xa62404dc: ('unknown_0xa62404dc', _decode_unknown_0xa62404dc),
0xbf8b57bf: ('unknown_0xbf8b57bf', _decode_unknown_0xbf8b57bf),
0x530ecf07: ('unknown_0x530ecf07', _decode_unknown_0x530ecf07),
0x8482e270: ('unknown_0x8482e270', _decode_unknown_0x8482e270),
0x7128f60e: ('unknown_0x7128f60e', _decode_unknown_0x7128f60e),
0xd9c4aa53: ('unknown_0xd9c4aa53', _decode_unknown_0xd9c4aa53),
0x8e13f1f6: ('left_target_attachment', _decode_left_target_attachment),
0x71c8e644: ('unknown_0x71c8e644', _decode_unknown_0x71c8e644),
0x8cb60fc9: ('unknown_0x8cb60fc9', _decode_unknown_0x8cb60fc9),
0x69a25f05: ('right_target_attachment', _decode_right_target_attachment),
0x967948b7: ('unknown_0x967948b7', _decode_unknown_0x967948b7),
0xa366c12: ('left_armor_attachment', _decode_left_armor_attachment),
0xf5ed7ba0: ('unknown_0xf5ed7ba0', _decode_unknown_0xf5ed7ba0),
0x3b5981c: ('right_armor_attachment', _decode_right_armor_attachment),
0xfc6e8fae: ('unknown_0xfc6e8fae', _decode_unknown_0xfc6e8fae),
0xbb5658b3: ('cmdl', _decode_cmdl),
0x448d4f01: ('unknown_0x448d4f01', _decode_unknown_0x448d4f01),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct19.py | 0.644673 | 0.195805 | UnknownStruct19.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
@dataclasses.dataclass()
class TeamAIDebugEnum(BaseProperty):
team_ai_state: enums.TeamAIState = dataclasses.field(default=enums.TeamAIState.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x01') # 1 properties
data.write(b'\x94\xd9{Z') # 0x94d97b5a
data.write(b'\x00\x04') # size
self.team_ai_state.to_stream(data)
@classmethod
def from_json(cls, data: dict):
return cls(
team_ai_state=enums.TeamAIState.from_json(data['team_ai_state']),
)
def to_json(self) -> dict:
return {
'team_ai_state': self.team_ai_state.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x94d97b5a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TeamAIDebugEnum]:
if property_count != 1:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(10))
if (dec[0]) != _FAST_IDS:
data.seek(before)
return None
return TeamAIDebugEnum(
enums.TeamAIState(dec[2]),
)
def _decode_team_ai_state(data: typing.BinaryIO, property_size: int):
return enums.TeamAIState.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x94d97b5a: ('team_ai_state', _decode_team_ai_state),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/TeamAIDebugEnum.py | 0.603231 | 0.293863 | TeamAIDebugEnum.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class LaunchProjectileData(BaseProperty):
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
delay: float = dataclasses.field(default=1.0)
delay_variance: float = dataclasses.field(default=0.0)
visor_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_visor_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
stop_homing_range: float = dataclasses.field(default=20.0)
burn_damage: float = dataclasses.field(default=1.0)
burn_duration: float = dataclasses.field(default=3.0)
targetable: bool = dataclasses.field(default=True)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
hit_points: float = dataclasses.field(default=1.0)
generate_pickup_chance: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x07') # 7 properties
num_properties_written = 7
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.projectile))
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'\xf7&\xe5\xda') # 0xf726e5da
data.write(b'\x00\x0c') # size
self.scale.to_stream(data)
data.write(b'\x14\xff\xf3\x9c') # 0x14fff39c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay))
data.write(b'}\xa8\xea#') # 0x7da8ea23
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_variance))
data.write(b'\xe9\xc8\xe2\xbd') # 0xe9c8e2bd
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.visor_effect))
data.write(b'\xa3\xe8\xecN') # 0xa3e8ec4e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_visor_effect))
if self.stop_homing_range != default_override.get('stop_homing_range', 20.0):
num_properties_written += 1
data.write(b'\x05:\xe4\xa7') # 0x53ae4a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stop_homing_range))
if self.burn_damage != default_override.get('burn_damage', 1.0):
num_properties_written += 1
data.write(b'\xcf \x1b\xfa') # 0xcf201bfa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.burn_damage))
if self.burn_duration != default_override.get('burn_duration', 3.0):
num_properties_written += 1
data.write(b'\x88\x13\x7f\xa8') # 0x88137fa8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.burn_duration))
if self.targetable != default_override.get('targetable', True):
num_properties_written += 1
data.write(b'\xb2\xd0##') # 0xb2d02323
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.targetable))
if self.collision_box != default_override.get('collision_box', Vector(x=1.0, y=1.0, z=1.0)):
num_properties_written += 1
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
if self.hit_points != default_override.get('hit_points', 1.0):
num_properties_written += 1
data.write(b'\x05k \xb2') # 0x56b20b2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hit_points))
if self.generate_pickup_chance != default_override.get('generate_pickup_chance', 0.0):
num_properties_written += 1
data.write(b'\xf7\x84i\xd6') # 0xf78469d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.generate_pickup_chance))
if num_properties_written != 7:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
projectile=data['projectile'],
damage=DamageInfo.from_json(data['damage']),
scale=Vector.from_json(data['scale']),
delay=data['delay'],
delay_variance=data['delay_variance'],
visor_effect=data['visor_effect'],
sound_visor_effect=data['sound_visor_effect'],
stop_homing_range=data['stop_homing_range'],
burn_damage=data['burn_damage'],
burn_duration=data['burn_duration'],
targetable=data['targetable'],
collision_box=Vector.from_json(data['collision_box']),
hit_points=data['hit_points'],
generate_pickup_chance=data['generate_pickup_chance'],
)
def to_json(self) -> dict:
return {
'projectile': self.projectile,
'damage': self.damage.to_json(),
'scale': self.scale.to_json(),
'delay': self.delay,
'delay_variance': self.delay_variance,
'visor_effect': self.visor_effect,
'sound_visor_effect': self.sound_visor_effect,
'stop_homing_range': self.stop_homing_range,
'burn_damage': self.burn_damage,
'burn_duration': self.burn_duration,
'targetable': self.targetable,
'collision_box': self.collision_box.to_json(),
'hit_points': self.hit_points,
'generate_pickup_chance': self.generate_pickup_chance,
}
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visor_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound_visor_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stop_homing_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_burn_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_burn_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_targetable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_hit_points(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_generate_pickup_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xef485db9: ('projectile', _decode_projectile),
0x337f9524: ('damage', _decode_damage),
0xf726e5da: ('scale', _decode_scale),
0x14fff39c: ('delay', _decode_delay),
0x7da8ea23: ('delay_variance', _decode_delay_variance),
0xe9c8e2bd: ('visor_effect', _decode_visor_effect),
0xa3e8ec4e: ('sound_visor_effect', _decode_sound_visor_effect),
0x53ae4a7: ('stop_homing_range', _decode_stop_homing_range),
0xcf201bfa: ('burn_damage', _decode_burn_damage),
0x88137fa8: ('burn_duration', _decode_burn_duration),
0xb2d02323: ('targetable', _decode_targetable),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x56b20b2: ('hit_points', _decode_hit_points),
0xf78469d6: ('generate_pickup_chance', _decode_generate_pickup_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/LaunchProjectileData.py | 0.511229 | 0.222193 | LaunchProjectileData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class OffsetInterpolant(BaseProperty):
x_offset: Spline = dataclasses.field(default_factory=Spline)
y_offset: Spline = dataclasses.field(default_factory=Spline)
z_offset: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'H[\x0c\x11') # 0x485b0c11
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xcd\xd5\x94') # 0x95cdd594
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x07\xb9Z') # 0x2807b95a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_offset=Spline.from_json(data['x_offset']),
y_offset=Spline.from_json(data['y_offset']),
z_offset=Spline.from_json(data['z_offset']),
)
def to_json(self) -> dict:
return {
'x_offset': self.x_offset.to_json(),
'y_offset': self.y_offset.to_json(),
'z_offset': self.z_offset.to_json(),
}
def _decode_x_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_offset(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x485b0c11: ('x_offset', _decode_x_offset),
0x95cdd594: ('y_offset', _decode_y_offset),
0x2807b95a: ('z_offset', _decode_z_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/OffsetInterpolant.py | 0.659295 | 0.312973 | OffsetInterpolant.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct7(BaseProperty):
unknown_0x174a5ec9: float = dataclasses.field(default=35.0)
unknown_0x87c20643: float = dataclasses.field(default=30.0)
cutting_beams_chance: float = dataclasses.field(default=35.0)
ground_spin_chance: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x04') # 4 properties
data.write(b'\x17J^\xc9') # 0x174a5ec9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x174a5ec9))
data.write(b'\x87\xc2\x06C') # 0x87c20643
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x87c20643))
data.write(b"\xc0'\x1d\xc6") # 0xc0271dc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cutting_beams_chance))
data.write(b'/Ld\x1f') # 0x2f4c641f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ground_spin_chance))
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0x174a5ec9=data['unknown_0x174a5ec9'],
unknown_0x87c20643=data['unknown_0x87c20643'],
cutting_beams_chance=data['cutting_beams_chance'],
ground_spin_chance=data['ground_spin_chance'],
)
def to_json(self) -> dict:
return {
'unknown_0x174a5ec9': self.unknown_0x174a5ec9,
'unknown_0x87c20643': self.unknown_0x87c20643,
'cutting_beams_chance': self.cutting_beams_chance,
'ground_spin_chance': self.ground_spin_chance,
}
_FAST_FORMAT = None
_FAST_IDS = (0x174a5ec9, 0x87c20643, 0xc0271dc6, 0x2f4c641f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct7]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct7(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_unknown_0x174a5ec9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x87c20643(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cutting_beams_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ground_spin_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x174a5ec9: ('unknown_0x174a5ec9', _decode_unknown_0x174a5ec9),
0x87c20643: ('unknown_0x87c20643', _decode_unknown_0x87c20643),
0xc0271dc6: ('cutting_beams_chance', _decode_cutting_beams_chance),
0x2f4c641f: ('ground_spin_chance', _decode_ground_spin_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct7.py | 0.600423 | 0.282797 | UnknownStruct7.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.RevolutionControl import RevolutionControl
@dataclasses.dataclass()
class DebugControls(BaseProperty):
move_camera: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xce9d8f9b: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xcf8d32f4: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x6e2701e2: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x233dfcb8: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x6c8eda79: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x52739b7b: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x936c903d: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xf3e413f0: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0x769412eb: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
toggle_camera: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xfc31e19e: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_start: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_up: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_down: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_left: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_right: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_select: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
menu_back: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xd38203d7: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xed1235d3: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown_0xc73501a3: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
restart_level: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
map_teleport: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
advance_frame: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x19') # 25 properties
data.write(b'8\xed\x0e\xc3') # 0x38ed0ec3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.move_camera.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xce\x9d\x8f\x9b') # 0xce9d8f9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xce9d8f9b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcf\x8d2\xf4') # 0xcf8d32f4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xcf8d32f4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"n'\x01\xe2") # 0x6e2701e2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x6e2701e2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#=\xfc\xb8') # 0x233dfcb8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x233dfcb8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l\x8e\xday') # 0x6c8eda79
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x6c8eda79.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Rs\x9b{') # 0x52739b7b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x52739b7b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93l\x90=') # 0x936c903d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x936c903d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3\xe4\x13\xf0') # 0xf3e413f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xf3e413f0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\x94\x12\xeb') # 0x769412eb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x769412eb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xce\x92\xbe\x94') # 0xce92be94
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.toggle_camera.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc1\xe1\x9e') # 0xfc31e19e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xfc31e19e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0b\xfc\xb7\xa2') # 0xbfcb7a2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_start.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\x99\t\xc1') # 0x769909c1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_up.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'M\xabi^') # 0x4dab695e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_down.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7\xca\xe2\xd3') # 0xc7cae2d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_left.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\x95\xf2v') # 0x1595f276
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_right.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\t\xb3\x8b') # 0xbf09b38b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_select.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\xbep\xf0') # 0xbcbe70f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.menu_back.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd3\x82\x03\xd7') # 0xd38203d7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xd38203d7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\x125\xd3') # 0xed1235d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xed1235d3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc75\x01\xa3') # 0xc73501a3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xc73501a3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5x\xca\r') # 0xc578ca0d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.restart_level.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xb2F0') # 0x8bb24630
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.map_teleport.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'L?\xa0;') # 0x4c3fa03b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.advance_frame.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
move_camera=RevolutionControl.from_json(data['move_camera']),
unknown_0xce9d8f9b=RevolutionControl.from_json(data['unknown_0xce9d8f9b']),
unknown_0xcf8d32f4=RevolutionControl.from_json(data['unknown_0xcf8d32f4']),
unknown_0x6e2701e2=RevolutionControl.from_json(data['unknown_0x6e2701e2']),
unknown_0x233dfcb8=RevolutionControl.from_json(data['unknown_0x233dfcb8']),
unknown_0x6c8eda79=RevolutionControl.from_json(data['unknown_0x6c8eda79']),
unknown_0x52739b7b=RevolutionControl.from_json(data['unknown_0x52739b7b']),
unknown_0x936c903d=RevolutionControl.from_json(data['unknown_0x936c903d']),
unknown_0xf3e413f0=RevolutionControl.from_json(data['unknown_0xf3e413f0']),
unknown_0x769412eb=RevolutionControl.from_json(data['unknown_0x769412eb']),
toggle_camera=RevolutionControl.from_json(data['toggle_camera']),
unknown_0xfc31e19e=RevolutionControl.from_json(data['unknown_0xfc31e19e']),
menu_start=RevolutionControl.from_json(data['menu_start']),
menu_up=RevolutionControl.from_json(data['menu_up']),
menu_down=RevolutionControl.from_json(data['menu_down']),
menu_left=RevolutionControl.from_json(data['menu_left']),
menu_right=RevolutionControl.from_json(data['menu_right']),
menu_select=RevolutionControl.from_json(data['menu_select']),
menu_back=RevolutionControl.from_json(data['menu_back']),
unknown_0xd38203d7=RevolutionControl.from_json(data['unknown_0xd38203d7']),
unknown_0xed1235d3=RevolutionControl.from_json(data['unknown_0xed1235d3']),
unknown_0xc73501a3=RevolutionControl.from_json(data['unknown_0xc73501a3']),
restart_level=RevolutionControl.from_json(data['restart_level']),
map_teleport=RevolutionControl.from_json(data['map_teleport']),
advance_frame=RevolutionControl.from_json(data['advance_frame']),
)
def to_json(self) -> dict:
return {
'move_camera': self.move_camera.to_json(),
'unknown_0xce9d8f9b': self.unknown_0xce9d8f9b.to_json(),
'unknown_0xcf8d32f4': self.unknown_0xcf8d32f4.to_json(),
'unknown_0x6e2701e2': self.unknown_0x6e2701e2.to_json(),
'unknown_0x233dfcb8': self.unknown_0x233dfcb8.to_json(),
'unknown_0x6c8eda79': self.unknown_0x6c8eda79.to_json(),
'unknown_0x52739b7b': self.unknown_0x52739b7b.to_json(),
'unknown_0x936c903d': self.unknown_0x936c903d.to_json(),
'unknown_0xf3e413f0': self.unknown_0xf3e413f0.to_json(),
'unknown_0x769412eb': self.unknown_0x769412eb.to_json(),
'toggle_camera': self.toggle_camera.to_json(),
'unknown_0xfc31e19e': self.unknown_0xfc31e19e.to_json(),
'menu_start': self.menu_start.to_json(),
'menu_up': self.menu_up.to_json(),
'menu_down': self.menu_down.to_json(),
'menu_left': self.menu_left.to_json(),
'menu_right': self.menu_right.to_json(),
'menu_select': self.menu_select.to_json(),
'menu_back': self.menu_back.to_json(),
'unknown_0xd38203d7': self.unknown_0xd38203d7.to_json(),
'unknown_0xed1235d3': self.unknown_0xed1235d3.to_json(),
'unknown_0xc73501a3': self.unknown_0xc73501a3.to_json(),
'restart_level': self.restart_level.to_json(),
'map_teleport': self.map_teleport.to_json(),
'advance_frame': self.advance_frame.to_json(),
}
def _decode_move_camera(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xce9d8f9b(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xcf8d32f4(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x6e2701e2(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x233dfcb8(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x6c8eda79(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x52739b7b(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x936c903d(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xf3e413f0(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0x769412eb(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_toggle_camera(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xfc31e19e(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_start(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_up(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_down(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_left(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_right(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_select(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_menu_back(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xd38203d7(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xed1235d3(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown_0xc73501a3(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_restart_level(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_map_teleport(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_advance_frame(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x38ed0ec3: ('move_camera', _decode_move_camera),
0xce9d8f9b: ('unknown_0xce9d8f9b', _decode_unknown_0xce9d8f9b),
0xcf8d32f4: ('unknown_0xcf8d32f4', _decode_unknown_0xcf8d32f4),
0x6e2701e2: ('unknown_0x6e2701e2', _decode_unknown_0x6e2701e2),
0x233dfcb8: ('unknown_0x233dfcb8', _decode_unknown_0x233dfcb8),
0x6c8eda79: ('unknown_0x6c8eda79', _decode_unknown_0x6c8eda79),
0x52739b7b: ('unknown_0x52739b7b', _decode_unknown_0x52739b7b),
0x936c903d: ('unknown_0x936c903d', _decode_unknown_0x936c903d),
0xf3e413f0: ('unknown_0xf3e413f0', _decode_unknown_0xf3e413f0),
0x769412eb: ('unknown_0x769412eb', _decode_unknown_0x769412eb),
0xce92be94: ('toggle_camera', _decode_toggle_camera),
0xfc31e19e: ('unknown_0xfc31e19e', _decode_unknown_0xfc31e19e),
0xbfcb7a2: ('menu_start', _decode_menu_start),
0x769909c1: ('menu_up', _decode_menu_up),
0x4dab695e: ('menu_down', _decode_menu_down),
0xc7cae2d3: ('menu_left', _decode_menu_left),
0x1595f276: ('menu_right', _decode_menu_right),
0xbf09b38b: ('menu_select', _decode_menu_select),
0xbcbe70f0: ('menu_back', _decode_menu_back),
0xd38203d7: ('unknown_0xd38203d7', _decode_unknown_0xd38203d7),
0xed1235d3: ('unknown_0xed1235d3', _decode_unknown_0xed1235d3),
0xc73501a3: ('unknown_0xc73501a3', _decode_unknown_0xc73501a3),
0xc578ca0d: ('restart_level', _decode_restart_level),
0x8bb24630: ('map_teleport', _decode_map_teleport),
0x4c3fa03b: ('advance_frame', _decode_advance_frame),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/DebugControls.py | 0.487307 | 0.213398 | DebugControls.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
@dataclasses.dataclass()
class DamageInfo(BaseProperty):
di_weapon_type: enums.DI_WeaponType = dataclasses.field(default=enums.DI_WeaponType.AI)
di_damage: float = dataclasses.field(default=0.0)
di_radius: float = dataclasses.field(default=0.0)
di_knock_back_power: float = dataclasses.field(default=0.0)
unknown: int = dataclasses.field(default=0)
adjust_for_difficulty: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x06') # 6 properties
data.write(b'D^\x00\xc8') # 0x445e00c8
data.write(b'\x00\x04') # size
self.di_weapon_type.to_stream(data)
data.write(b'\xf2\xd0&\x13') # 0xf2d02613
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_damage))
data.write(b'\xee\x1b\xe9\x14') # 0xee1be914
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_radius))
data.write(b'U_\xf8\n') # 0x555ff80a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.di_knock_back_power))
data.write(b'z?\xe0\r') # 0x7a3fe00d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\xef\xe9\xe4e') # 0xefe9e465
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.adjust_for_difficulty))
@classmethod
def from_json(cls, data: dict):
return cls(
di_weapon_type=enums.DI_WeaponType.from_json(data['di_weapon_type']),
di_damage=data['di_damage'],
di_radius=data['di_radius'],
di_knock_back_power=data['di_knock_back_power'],
unknown=data['unknown'],
adjust_for_difficulty=data['adjust_for_difficulty'],
)
def to_json(self) -> dict:
return {
'di_weapon_type': self.di_weapon_type.to_json(),
'di_damage': self.di_damage,
'di_radius': self.di_radius,
'di_knock_back_power': self.di_knock_back_power,
'unknown': self.unknown,
'adjust_for_difficulty': self.adjust_for_difficulty,
}
_FAST_FORMAT = None
_FAST_IDS = (0x445e00c8, 0xf2d02613, 0xee1be914, 0x555ff80a, 0x7a3fe00d, 0xefe9e465)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DamageInfo]:
if property_count != 6:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHfLHfLHfLHlLH?')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(57))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15]) != _FAST_IDS:
data.seek(before)
return None
return DamageInfo(
enums.DI_WeaponType(dec[2]),
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
)
def _decode_di_weapon_type(data: typing.BinaryIO, property_size: int):
return enums.DI_WeaponType.from_stream(data)
def _decode_di_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_di_knock_back_power(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_adjust_for_difficulty(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]]] = {
0x445e00c8: ('di_weapon_type', _decode_di_weapon_type),
0xf2d02613: ('di_damage', _decode_di_damage),
0xee1be914: ('di_radius', _decode_di_radius),
0x555ff80a: ('di_knock_back_power', _decode_di_knock_back_power),
0x7a3fe00d: ('unknown', _decode_unknown),
0xefe9e465: ('adjust_for_difficulty', _decode_adjust_for_difficulty),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/DamageInfo.py | 0.609873 | 0.258402 | DamageInfo.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.archetypes.InterpolationMethod import InterpolationMethod
@dataclasses.dataclass()
class OrientationInterpolationMethod(BaseProperty):
orientation_type: enums.OrientationType = dataclasses.field(default=enums.OrientationType.Unknown1)
orientation_control: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'\\r\xa9d') # 0x5c72a964
data.write(b'\x00\x04') # size
self.orientation_type.to_stream(data)
data.write(b'\x86T\xb0\x81') # 0x8654b081
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
orientation_type=enums.OrientationType.from_json(data['orientation_type']),
orientation_control=InterpolationMethod.from_json(data['orientation_control']),
)
def to_json(self) -> dict:
return {
'orientation_type': self.orientation_type.to_json(),
'orientation_control': self.orientation_control.to_json(),
}
def _decode_orientation_type(data: typing.BinaryIO, property_size: int):
return enums.OrientationType.from_stream(data)
def _decode_orientation_control(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5c72a964: ('orientation_type', _decode_orientation_type),
0x8654b081: ('orientation_control', _decode_orientation_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/OrientationInterpolationMethod.py | 0.680135 | 0.290232 | OrientationInterpolationMethod.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.UnknownStruct10 import UnknownStruct10
@dataclasses.dataclass()
class SpriteStruct(BaseProperty):
loop: bool = dataclasses.field(default=False)
unknown_struct10_0x30613ecc: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0x19a98a3e: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0xb7c11baf: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0x4a38e3da: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0xe450724b: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0xcd98c6b9: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0x63f05728: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0xed1a3012: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0x4372a183: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct10_0x2060e2f5: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0b') # 11 properties
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'0a>\xcc') # 0x30613ecc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0x30613ecc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\xa9\x8a>') # 0x19a98a3e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0x19a98a3e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb7\xc1\x1b\xaf') # 0xb7c11baf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0xb7c11baf.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J8\xe3\xda') # 0x4a38e3da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0x4a38e3da.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4PrK') # 0xe450724b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0xe450724b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcd\x98\xc6\xb9') # 0xcd98c6b9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0xcd98c6b9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c\xf0W(') # 0x63f05728
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0x63f05728.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\x1a0\x12') # 0xed1a3012
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0xed1a3012.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Cr\xa1\x83') # 0x4372a183
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0x4372a183.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' `\xe2\xf5') # 0x2060e2f5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10_0x2060e2f5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
loop=data['loop'],
unknown_struct10_0x30613ecc=UnknownStruct10.from_json(data['unknown_struct10_0x30613ecc']),
unknown_struct10_0x19a98a3e=UnknownStruct10.from_json(data['unknown_struct10_0x19a98a3e']),
unknown_struct10_0xb7c11baf=UnknownStruct10.from_json(data['unknown_struct10_0xb7c11baf']),
unknown_struct10_0x4a38e3da=UnknownStruct10.from_json(data['unknown_struct10_0x4a38e3da']),
unknown_struct10_0xe450724b=UnknownStruct10.from_json(data['unknown_struct10_0xe450724b']),
unknown_struct10_0xcd98c6b9=UnknownStruct10.from_json(data['unknown_struct10_0xcd98c6b9']),
unknown_struct10_0x63f05728=UnknownStruct10.from_json(data['unknown_struct10_0x63f05728']),
unknown_struct10_0xed1a3012=UnknownStruct10.from_json(data['unknown_struct10_0xed1a3012']),
unknown_struct10_0x4372a183=UnknownStruct10.from_json(data['unknown_struct10_0x4372a183']),
unknown_struct10_0x2060e2f5=UnknownStruct10.from_json(data['unknown_struct10_0x2060e2f5']),
)
def to_json(self) -> dict:
return {
'loop': self.loop,
'unknown_struct10_0x30613ecc': self.unknown_struct10_0x30613ecc.to_json(),
'unknown_struct10_0x19a98a3e': self.unknown_struct10_0x19a98a3e.to_json(),
'unknown_struct10_0xb7c11baf': self.unknown_struct10_0xb7c11baf.to_json(),
'unknown_struct10_0x4a38e3da': self.unknown_struct10_0x4a38e3da.to_json(),
'unknown_struct10_0xe450724b': self.unknown_struct10_0xe450724b.to_json(),
'unknown_struct10_0xcd98c6b9': self.unknown_struct10_0xcd98c6b9.to_json(),
'unknown_struct10_0x63f05728': self.unknown_struct10_0x63f05728.to_json(),
'unknown_struct10_0xed1a3012': self.unknown_struct10_0xed1a3012.to_json(),
'unknown_struct10_0x4372a183': self.unknown_struct10_0x4372a183.to_json(),
'unknown_struct10_0x2060e2f5': self.unknown_struct10_0x2060e2f5.to_json(),
}
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct10_0x30613ecc(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0x19a98a3e(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0xb7c11baf(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0x4a38e3da(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0xe450724b(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0xcd98c6b9(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0x63f05728(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0xed1a3012(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0x4372a183(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct10_0x2060e2f5(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xeda47ff6: ('loop', _decode_loop),
0x30613ecc: ('unknown_struct10_0x30613ecc', _decode_unknown_struct10_0x30613ecc),
0x19a98a3e: ('unknown_struct10_0x19a98a3e', _decode_unknown_struct10_0x19a98a3e),
0xb7c11baf: ('unknown_struct10_0xb7c11baf', _decode_unknown_struct10_0xb7c11baf),
0x4a38e3da: ('unknown_struct10_0x4a38e3da', _decode_unknown_struct10_0x4a38e3da),
0xe450724b: ('unknown_struct10_0xe450724b', _decode_unknown_struct10_0xe450724b),
0xcd98c6b9: ('unknown_struct10_0xcd98c6b9', _decode_unknown_struct10_0xcd98c6b9),
0x63f05728: ('unknown_struct10_0x63f05728', _decode_unknown_struct10_0x63f05728),
0xed1a3012: ('unknown_struct10_0xed1a3012', _decode_unknown_struct10_0xed1a3012),
0x4372a183: ('unknown_struct10_0x4372a183', _decode_unknown_struct10_0x4372a183),
0x2060e2f5: ('unknown_struct10_0x2060e2f5', _decode_unknown_struct10_0x2060e2f5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/SpriteStruct.py | 0.483161 | 0.261396 | SpriteStruct.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.archetypes.Convergence import Convergence
from retro_data_structures.properties.corruption.archetypes.PathDetermination import PathDetermination
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class PathPosition(BaseProperty):
flags_path_position: int = dataclasses.field(default=0) # Flagset
initial_position: enums.InitialPosition = dataclasses.field(default=enums.InitialPosition.Unknown1)
path_determination: PathDetermination = dataclasses.field(default_factory=PathDetermination)
distance: float = dataclasses.field(default=4.0)
dampen_distance: float = dataclasses.field(default=3.0)
convergence: Convergence = dataclasses.field(default_factory=Convergence)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
unknown: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'%\x9d2y') # 0x259d3279
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_path_position))
data.write(b'4\x0eL\xa3') # 0x340e4ca3
data.write(b'\x00\x04') # size
self.initial_position.to_stream(data)
data.write(b'\n\xed\\}') # 0xaed5c7d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_determination.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'2\xf85\xec') # 0x32f835ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dampen_distance))
data.write(b'\x95\x91\x08\xa5') # 0x959108a5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.convergence.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\x86\x1f}') # 0x12861f7d
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)
@classmethod
def from_json(cls, data: dict):
return cls(
flags_path_position=data['flags_path_position'],
initial_position=enums.InitialPosition.from_json(data['initial_position']),
path_determination=PathDetermination.from_json(data['path_determination']),
distance=data['distance'],
dampen_distance=data['dampen_distance'],
convergence=Convergence.from_json(data['convergence']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
unknown=Spline.from_json(data['unknown']),
)
def to_json(self) -> dict:
return {
'flags_path_position': self.flags_path_position,
'initial_position': self.initial_position.to_json(),
'path_determination': self.path_determination.to_json(),
'distance': self.distance,
'dampen_distance': self.dampen_distance,
'convergence': self.convergence.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'unknown': self.unknown.to_json(),
}
def _decode_flags_path_position(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_initial_position(data: typing.BinaryIO, property_size: int):
return enums.InitialPosition.from_stream(data)
def _decode_path_determination(data: typing.BinaryIO, property_size: int):
return PathDetermination.from_stream(data, property_size)
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dampen_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_convergence(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_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]]] = {
0x259d3279: ('flags_path_position', _decode_flags_path_position),
0x340e4ca3: ('initial_position', _decode_initial_position),
0xaed5c7d: ('path_determination', _decode_path_determination),
0xc3bf43be: ('distance', _decode_distance),
0x32f835ec: ('dampen_distance', _decode_dampen_distance),
0x959108a5: ('convergence', _decode_convergence),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0x12861f7d: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/PathPosition.py | 0.664976 | 0.294139 | PathPosition.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.FlyerMovementMode import FlyerMovementMode
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MetroidHatcherData(BaseProperty):
hearing_range: float = dataclasses.field(default=25.0)
lose_interest_range: float = dataclasses.field(default=50.0)
lose_interest_time: float = dataclasses.field(default=10.0)
unknown_0xfe4588a1: float = dataclasses.field(default=50.0)
unknown_0xc2688b41: float = dataclasses.field(default=0.5)
unknown_0x7b0cc30d: float = dataclasses.field(default=60.0)
damage_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
body_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
brain_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
brain_x_ray_radius: float = dataclasses.field(default=1.0)
brain_radius: float = dataclasses.field(default=0.10000000149011612)
leg_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0xb9e0c90d: float = dataclasses.field(default=20.0)
unknown_0x81d39802: float = dataclasses.field(default=0.10000000149011612)
tentacle_regrow_time: float = dataclasses.field(default=0.33329999446868896)
unknown_0xf79a10b0: float = dataclasses.field(default=0.5)
unknown_0xc550a481: float = dataclasses.field(default=0.10000000149011612)
unknown_0x95e7a2c2: float = dataclasses.field(default=10.0)
unknown_0x76ba1c18: float = dataclasses.field(default=15.0)
unknown_0xe08106ed: float = dataclasses.field(default=5.0)
unknown_0x88d7c540: float = dataclasses.field(default=5.0)
unknown_0xace62367: float = dataclasses.field(default=5.0)
unknown_0x620b1b3d: float = dataclasses.field(default=5.0)
max_attack_height: float = dataclasses.field(default=10.0)
min_attack_height: float = dataclasses.field(default=9.0)
max_attack_forward: float = dataclasses.field(default=16.0)
min_attack_forward: float = dataclasses.field(default=14.0)
unknown_0x0978b98a: float = dataclasses.field(default=10.0)
unknown_0xcfcd32bb: float = dataclasses.field(default=-1.5)
unknown_0x17d71349: float = dataclasses.field(default=8.0)
recheck_path_time: float = dataclasses.field(default=1.0)
recheck_path_distance: float = dataclasses.field(default=5.0)
max_num_metroids: int = dataclasses.field(default=3)
auto_spawn: bool = dataclasses.field(default=False)
max_spawn_delay: float = dataclasses.field(default=30.0)
min_spawn_delay: float = dataclasses.field(default=20.0)
unknown_0x6089191d: int = dataclasses.field(default=10)
unknown_0x258b5a9f: int = dataclasses.field(default=5)
unknown_0x2ae610e5: float = dataclasses.field(default=20.0)
hatch_chance: float = dataclasses.field(default=0.699999988079071)
maya_double: float = dataclasses.field(default=0.5)
unknown_0x3fee1ba4: float = dataclasses.field(default=0.5)
spin_attack_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
max_spin_attack_delay: float = dataclasses.field(default=20.0)
min_spin_attack_delay: float = dataclasses.field(default=10.0)
unknown_0xbeaf2105: float = dataclasses.field(default=15.0)
unknown_0x54ff4d38: float = dataclasses.field(default=3.0)
unknown_0xb29fe2d9: float = dataclasses.field(default=2.0)
dodge_chance: float = dataclasses.field(default=0.0010000000474974513)
unknown_0x42647ad7: float = dataclasses.field(default=100.0)
unknown_0xa404d536: float = dataclasses.field(default=15.0)
unknown_0x248d3599: float = dataclasses.field(default=0.10000000149011612)
unknown_0xbfd77e62: float = dataclasses.field(default=0.10000000149011612)
unknown_0xcdaa2c74: float = dataclasses.field(default=30.0)
unknown_0x2bca8395: float = dataclasses.field(default=10.0)
patrol: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
attack_path: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
combat: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
stab_attack: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0x6ca56014: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0xe20e51c3: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0x25a68a0e: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0xd9b5d506: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0x8bb1c3a2: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
stunned: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0xfb2ddfad: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
dash: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flyer_movement_mode_0x5fe13a7b: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
claw: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
char_0x4d7dbeab: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
char_0xa17c09bb: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
char_0x11dc2dab: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
char_0xfddd9abb: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0xc99cee00: float = dataclasses.field(default=0.6000000238418579)
unknown_0x2ffc41e1: float = dataclasses.field(default=0.4000000059604645)
unknown_0x7f5d9ab7: float = dataclasses.field(default=0.800000011920929)
unknown_0x993d3556: float = dataclasses.field(default=0.5)
unknown_0x08efeb79: float = dataclasses.field(default=0.0)
unknown_0xee8f4498: float = dataclasses.field(default=0.0)
unknown_0xc24d8fbd: float = dataclasses.field(default=20.0)
unknown_0x242d205c: float = dataclasses.field(default=15.0)
stun_threshold: float = dataclasses.field(default=30.0)
electric_ball_effect: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
sound_ball_effect: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
electric_visor_effect: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
sound_visor_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
leg_hit_splash: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00W') # 87 properties
data.write(b'%GEP') # 0x25474550
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hearing_range))
data.write(b'GO\xa5\x89') # 0x474fa589
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lose_interest_range))
data.write(b'\xf8\xb0\xc2\xbb') # 0xf8b0c2bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lose_interest_time))
data.write(b'\xfeE\x88\xa1') # 0xfe4588a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfe4588a1))
data.write(b'\xc2h\x8bA') # 0xc2688b41
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc2688b41))
data.write(b'{\x0c\xc3\r') # 0x7b0cc30d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7b0cc30d))
data.write(b't+36') # 0x742b3336
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\r\x920\xd1') # 0xd9230d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.body_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$:\xb1\r') # 0x243ab10d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.brain_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01!\x15\xa2') # 0x12115a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.brain_x_ray_radius))
data.write(b'\xa1*D\t') # 0xa12a4409
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.brain_radius))
data.write(b'\x9f\x0f\xf8R') # 0x9f0ff852
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.leg_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\xe0\xc9\r') # 0xb9e0c90d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb9e0c90d))
data.write(b'\x81\xd3\x98\x02') # 0x81d39802
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x81d39802))
data.write(b'\xba\x00-\xcb') # 0xba002dcb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.tentacle_regrow_time))
data.write(b'\xf7\x9a\x10\xb0') # 0xf79a10b0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf79a10b0))
data.write(b'\xc5P\xa4\x81') # 0xc550a481
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc550a481))
data.write(b'\x95\xe7\xa2\xc2') # 0x95e7a2c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x95e7a2c2))
data.write(b'v\xba\x1c\x18') # 0x76ba1c18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76ba1c18))
data.write(b'\xe0\x81\x06\xed') # 0xe08106ed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe08106ed))
data.write(b'\x88\xd7\xc5@') # 0x88d7c540
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x88d7c540))
data.write(b'\xac\xe6#g') # 0xace62367
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xace62367))
data.write(b'b\x0b\x1b=') # 0x620b1b3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x620b1b3d))
data.write(b'\xe1\xaeQ\xd8') # 0xe1ae51d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_height))
data.write(b'\xc8\xd0\xac\xc0') # 0xc8d0acc0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attack_height))
data.write(b'\xf3\xe8\x01-') # 0xf3e8012d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_forward))
data.write(b'\xe0\xad\xe7\x86') # 0xe0ade786
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attack_forward))
data.write(b'\tx\xb9\x8a') # 0x978b98a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0978b98a))
data.write(b'\xcf\xcd2\xbb') # 0xcfcd32bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcfcd32bb))
data.write(b'\x17\xd7\x13I') # 0x17d71349
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x17d71349))
data.write(b'\x9a\xa9\x0bk') # 0x9aa90b6b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.recheck_path_time))
data.write(b'v&\xec\x89') # 0x7626ec89
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.recheck_path_distance))
data.write(b'y\x15\xe2\xb3') # 0x7915e2b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_num_metroids))
data.write(b'\xcc\xc0\xcf\x92') # 0xccc0cf92
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_spawn))
data.write(b'u\xe0\xb0\xa7') # 0x75e0b0a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_spawn_delay))
data.write(b'&F\xa8C') # 0x2646a843
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_spawn_delay))
data.write(b'`\x89\x19\x1d') # 0x6089191d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6089191d))
data.write(b'%\x8bZ\x9f') # 0x258b5a9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x258b5a9f))
data.write(b'*\xe6\x10\xe5') # 0x2ae610e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2ae610e5))
data.write(b'5K\xae1') # 0x354bae31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hatch_chance))
data.write(b'\xf4\xb2\xc8\x01') # 0xf4b2c801
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maya_double))
data.write(b'?\xee\x1b\xa4') # 0x3fee1ba4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3fee1ba4))
data.write(b'\xcf\xac\xffS') # 0xcfacff53
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spin_attack_damage.to_stream(data, default_override={'di_damage': 30.0, 'di_knock_back_power': 20.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l\xb6\xd8\xc7') # 0x6cb6d8c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_spin_attack_delay))
data.write(b'h,\xe9\xed') # 0x682ce9ed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_spin_attack_delay))
data.write(b'\xbe\xaf!\x05') # 0xbeaf2105
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbeaf2105))
data.write(b'T\xffM8') # 0x54ff4d38
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x54ff4d38))
data.write(b'\xb2\x9f\xe2\xd9') # 0xb29fe2d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb29fe2d9))
data.write(b'G\xbe2\x98') # 0x47be3298
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dodge_chance))
data.write(b'Bdz\xd7') # 0x42647ad7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x42647ad7))
data.write(b'\xa4\x04\xd56') # 0xa404d536
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa404d536))
data.write(b'$\x8d5\x99') # 0x248d3599
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x248d3599))
data.write(b'\xbf\xd7~b') # 0xbfd77e62
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbfd77e62))
data.write(b'\xcd\xaa,t') # 0xcdaa2c74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcdaa2c74))
data.write(b'+\xca\x83\x95') # 0x2bca8395
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2bca8395))
data.write(b'\xcc\xdd:\xca') # 0xccdd3aca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patrol.to_stream(data, default_override={'speed': 3.0, 'acceleration': 1.0, 'facing_turn_rate': 30.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8E\xd3\xc0') # 0xc845d3c0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_path.to_stream(data, default_override={'speed': 3.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc}.\x98') # 0xcc7d2e98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.combat.to_stream(data, default_override={'speed': 3.0, 'acceleration': 10.0, 'turn_threshold': 181.0, 'floor_buffer': 11.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\xc3\xdb\x94') # 0xb9c3db94
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.stab_attack.to_stream(data, default_override={'speed': 0.10000000149011612, 'acceleration': 10.0, 'turn_rate': 10800.0, 'facing_turn_rate': 120.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 0.0, 'floor_buffer': 8.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l\xa5`\x14') # 0x6ca56014
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0x6ca56014.to_stream(data, default_override={'speed': 30.0, 'acceleration': 50.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 0.0, 'floor_buffer': 3.5, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2\x0eQ\xc3') # 0xe20e51c3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0xe20e51c3.to_stream(data, default_override={'speed': 30.0, 'acceleration': 10.0, 'facing_turn_rate': 1.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 1.0, 'floor_buffer': 5.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%\xa6\x8a\x0e') # 0x25a68a0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0x25a68a0e.to_stream(data, default_override={'speed': 1.0, 'acceleration': 10.0, 'turn_threshold': 181.0, 'height_variation_max': 0.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd9\xb5\xd5\x06') # 0xd9b5d506
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0xd9b5d506.to_stream(data, default_override={'speed': 30.0, 'acceleration': 20.0, 'facing_turn_rate': 1.0, 'turn_threshold': 181.0, 'height_variation_max': 1.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xb1\xc3\xa2') # 0x8bb1c3a2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0x8bb1c3a2.to_stream(data, default_override={'speed': 1.0, 'acceleration': 10.0, 'turn_threshold': 181.0, 'height_variation_max': 1.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'8\x9c\xb5\x15') # 0x389cb515
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.stunned.to_stream(data, default_override={'speed': 5.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 1.0, 'floor_buffer': 5.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfb-\xdf\xad') # 0xfb2ddfad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0xfb2ddfad.to_stream(data, default_override={'speed': 5.0, 'acceleration': 10.0, 'facing_turn_rate': 15.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_min': 1.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5X\xbc\r') # 0xc558bc0d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dash.to_stream(data, default_override={'speed': 40.0, 'acceleration': 100.0, 'turn_rate': 360.0, 'turn_threshold': 181.0, 'avoidance_range': 1.0, 'height_variation_max': 0.5, 'floor_buffer': 13.0, 'ceiling_buffer': 8.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'_\xe1:{') # 0x5fe13a7b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_movement_mode_0x5fe13a7b.to_stream(data, default_override={'acceleration': 20.0, 'turn_threshold': 181.0, 'floor_buffer': 12.0, 'ceiling_buffer': 12.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd8\xa1\x06') # 0xfd38a106
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.claw.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'M}\xbe\xab') # 0x4d7dbeab
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char_0x4d7dbeab.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1|\t\xbb') # 0xa17c09bb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char_0xa17c09bb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x11\xdc-\xab') # 0x11dc2dab
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char_0x11dc2dab.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\xdd\x9a\xbb') # 0xfddd9abb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char_0xfddd9abb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9\x9c\xee\x00') # 0xc99cee00
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc99cee00))
data.write(b'/\xfcA\xe1') # 0x2ffc41e1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2ffc41e1))
data.write(b'\x7f]\x9a\xb7') # 0x7f5d9ab7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7f5d9ab7))
data.write(b'\x99=5V') # 0x993d3556
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x993d3556))
data.write(b'\x08\xef\xeby') # 0x8efeb79
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x08efeb79))
data.write(b'\xee\x8fD\x98') # 0xee8f4498
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xee8f4498))
data.write(b'\xc2M\x8f\xbd') # 0xc24d8fbd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc24d8fbd))
data.write(b'$- \\') # 0x242d205c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x242d205c))
data.write(b'[\xdd\x1eL') # 0x5bdd1e4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stun_threshold))
data.write(b'm\xa4\xa3\xb0') # 0x6da4a3b0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.electric_ball_effect))
data.write(b'?\xcd\x8bf') # 0x3fcd8b66
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_ball_effect))
data.write(b'\xcc\n\xf2\x87') # 0xcc0af287
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.electric_visor_effect))
data.write(b'\xa3\xe8\xecN') # 0xa3e8ec4e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_visor_effect))
data.write(b'\xf4\n\x9c\x9d') # 0xf40a9c9d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.leg_hit_splash))
@classmethod
def from_json(cls, data: dict):
return cls(
hearing_range=data['hearing_range'],
lose_interest_range=data['lose_interest_range'],
lose_interest_time=data['lose_interest_time'],
unknown_0xfe4588a1=data['unknown_0xfe4588a1'],
unknown_0xc2688b41=data['unknown_0xc2688b41'],
unknown_0x7b0cc30d=data['unknown_0x7b0cc30d'],
damage_vulnerability=DamageVulnerability.from_json(data['damage_vulnerability']),
body_vulnerability=DamageVulnerability.from_json(data['body_vulnerability']),
brain_vulnerability=DamageVulnerability.from_json(data['brain_vulnerability']),
brain_x_ray_radius=data['brain_x_ray_radius'],
brain_radius=data['brain_radius'],
leg_vulnerability=DamageVulnerability.from_json(data['leg_vulnerability']),
unknown_0xb9e0c90d=data['unknown_0xb9e0c90d'],
unknown_0x81d39802=data['unknown_0x81d39802'],
tentacle_regrow_time=data['tentacle_regrow_time'],
unknown_0xf79a10b0=data['unknown_0xf79a10b0'],
unknown_0xc550a481=data['unknown_0xc550a481'],
unknown_0x95e7a2c2=data['unknown_0x95e7a2c2'],
unknown_0x76ba1c18=data['unknown_0x76ba1c18'],
unknown_0xe08106ed=data['unknown_0xe08106ed'],
unknown_0x88d7c540=data['unknown_0x88d7c540'],
unknown_0xace62367=data['unknown_0xace62367'],
unknown_0x620b1b3d=data['unknown_0x620b1b3d'],
max_attack_height=data['max_attack_height'],
min_attack_height=data['min_attack_height'],
max_attack_forward=data['max_attack_forward'],
min_attack_forward=data['min_attack_forward'],
unknown_0x0978b98a=data['unknown_0x0978b98a'],
unknown_0xcfcd32bb=data['unknown_0xcfcd32bb'],
unknown_0x17d71349=data['unknown_0x17d71349'],
recheck_path_time=data['recheck_path_time'],
recheck_path_distance=data['recheck_path_distance'],
max_num_metroids=data['max_num_metroids'],
auto_spawn=data['auto_spawn'],
max_spawn_delay=data['max_spawn_delay'],
min_spawn_delay=data['min_spawn_delay'],
unknown_0x6089191d=data['unknown_0x6089191d'],
unknown_0x258b5a9f=data['unknown_0x258b5a9f'],
unknown_0x2ae610e5=data['unknown_0x2ae610e5'],
hatch_chance=data['hatch_chance'],
maya_double=data['maya_double'],
unknown_0x3fee1ba4=data['unknown_0x3fee1ba4'],
spin_attack_damage=DamageInfo.from_json(data['spin_attack_damage']),
max_spin_attack_delay=data['max_spin_attack_delay'],
min_spin_attack_delay=data['min_spin_attack_delay'],
unknown_0xbeaf2105=data['unknown_0xbeaf2105'],
unknown_0x54ff4d38=data['unknown_0x54ff4d38'],
unknown_0xb29fe2d9=data['unknown_0xb29fe2d9'],
dodge_chance=data['dodge_chance'],
unknown_0x42647ad7=data['unknown_0x42647ad7'],
unknown_0xa404d536=data['unknown_0xa404d536'],
unknown_0x248d3599=data['unknown_0x248d3599'],
unknown_0xbfd77e62=data['unknown_0xbfd77e62'],
unknown_0xcdaa2c74=data['unknown_0xcdaa2c74'],
unknown_0x2bca8395=data['unknown_0x2bca8395'],
patrol=FlyerMovementMode.from_json(data['patrol']),
attack_path=FlyerMovementMode.from_json(data['attack_path']),
combat=FlyerMovementMode.from_json(data['combat']),
stab_attack=FlyerMovementMode.from_json(data['stab_attack']),
flyer_movement_mode_0x6ca56014=FlyerMovementMode.from_json(data['flyer_movement_mode_0x6ca56014']),
flyer_movement_mode_0xe20e51c3=FlyerMovementMode.from_json(data['flyer_movement_mode_0xe20e51c3']),
flyer_movement_mode_0x25a68a0e=FlyerMovementMode.from_json(data['flyer_movement_mode_0x25a68a0e']),
flyer_movement_mode_0xd9b5d506=FlyerMovementMode.from_json(data['flyer_movement_mode_0xd9b5d506']),
flyer_movement_mode_0x8bb1c3a2=FlyerMovementMode.from_json(data['flyer_movement_mode_0x8bb1c3a2']),
stunned=FlyerMovementMode.from_json(data['stunned']),
flyer_movement_mode_0xfb2ddfad=FlyerMovementMode.from_json(data['flyer_movement_mode_0xfb2ddfad']),
dash=FlyerMovementMode.from_json(data['dash']),
flyer_movement_mode_0x5fe13a7b=FlyerMovementMode.from_json(data['flyer_movement_mode_0x5fe13a7b']),
claw=AnimationParameters.from_json(data['claw']),
char_0x4d7dbeab=AnimationParameters.from_json(data['char_0x4d7dbeab']),
char_0xa17c09bb=AnimationParameters.from_json(data['char_0xa17c09bb']),
char_0x11dc2dab=AnimationParameters.from_json(data['char_0x11dc2dab']),
char_0xfddd9abb=AnimationParameters.from_json(data['char_0xfddd9abb']),
unknown_0xc99cee00=data['unknown_0xc99cee00'],
unknown_0x2ffc41e1=data['unknown_0x2ffc41e1'],
unknown_0x7f5d9ab7=data['unknown_0x7f5d9ab7'],
unknown_0x993d3556=data['unknown_0x993d3556'],
unknown_0x08efeb79=data['unknown_0x08efeb79'],
unknown_0xee8f4498=data['unknown_0xee8f4498'],
unknown_0xc24d8fbd=data['unknown_0xc24d8fbd'],
unknown_0x242d205c=data['unknown_0x242d205c'],
stun_threshold=data['stun_threshold'],
electric_ball_effect=data['electric_ball_effect'],
sound_ball_effect=data['sound_ball_effect'],
electric_visor_effect=data['electric_visor_effect'],
sound_visor_effect=data['sound_visor_effect'],
leg_hit_splash=data['leg_hit_splash'],
)
def to_json(self) -> dict:
return {
'hearing_range': self.hearing_range,
'lose_interest_range': self.lose_interest_range,
'lose_interest_time': self.lose_interest_time,
'unknown_0xfe4588a1': self.unknown_0xfe4588a1,
'unknown_0xc2688b41': self.unknown_0xc2688b41,
'unknown_0x7b0cc30d': self.unknown_0x7b0cc30d,
'damage_vulnerability': self.damage_vulnerability.to_json(),
'body_vulnerability': self.body_vulnerability.to_json(),
'brain_vulnerability': self.brain_vulnerability.to_json(),
'brain_x_ray_radius': self.brain_x_ray_radius,
'brain_radius': self.brain_radius,
'leg_vulnerability': self.leg_vulnerability.to_json(),
'unknown_0xb9e0c90d': self.unknown_0xb9e0c90d,
'unknown_0x81d39802': self.unknown_0x81d39802,
'tentacle_regrow_time': self.tentacle_regrow_time,
'unknown_0xf79a10b0': self.unknown_0xf79a10b0,
'unknown_0xc550a481': self.unknown_0xc550a481,
'unknown_0x95e7a2c2': self.unknown_0x95e7a2c2,
'unknown_0x76ba1c18': self.unknown_0x76ba1c18,
'unknown_0xe08106ed': self.unknown_0xe08106ed,
'unknown_0x88d7c540': self.unknown_0x88d7c540,
'unknown_0xace62367': self.unknown_0xace62367,
'unknown_0x620b1b3d': self.unknown_0x620b1b3d,
'max_attack_height': self.max_attack_height,
'min_attack_height': self.min_attack_height,
'max_attack_forward': self.max_attack_forward,
'min_attack_forward': self.min_attack_forward,
'unknown_0x0978b98a': self.unknown_0x0978b98a,
'unknown_0xcfcd32bb': self.unknown_0xcfcd32bb,
'unknown_0x17d71349': self.unknown_0x17d71349,
'recheck_path_time': self.recheck_path_time,
'recheck_path_distance': self.recheck_path_distance,
'max_num_metroids': self.max_num_metroids,
'auto_spawn': self.auto_spawn,
'max_spawn_delay': self.max_spawn_delay,
'min_spawn_delay': self.min_spawn_delay,
'unknown_0x6089191d': self.unknown_0x6089191d,
'unknown_0x258b5a9f': self.unknown_0x258b5a9f,
'unknown_0x2ae610e5': self.unknown_0x2ae610e5,
'hatch_chance': self.hatch_chance,
'maya_double': self.maya_double,
'unknown_0x3fee1ba4': self.unknown_0x3fee1ba4,
'spin_attack_damage': self.spin_attack_damage.to_json(),
'max_spin_attack_delay': self.max_spin_attack_delay,
'min_spin_attack_delay': self.min_spin_attack_delay,
'unknown_0xbeaf2105': self.unknown_0xbeaf2105,
'unknown_0x54ff4d38': self.unknown_0x54ff4d38,
'unknown_0xb29fe2d9': self.unknown_0xb29fe2d9,
'dodge_chance': self.dodge_chance,
'unknown_0x42647ad7': self.unknown_0x42647ad7,
'unknown_0xa404d536': self.unknown_0xa404d536,
'unknown_0x248d3599': self.unknown_0x248d3599,
'unknown_0xbfd77e62': self.unknown_0xbfd77e62,
'unknown_0xcdaa2c74': self.unknown_0xcdaa2c74,
'unknown_0x2bca8395': self.unknown_0x2bca8395,
'patrol': self.patrol.to_json(),
'attack_path': self.attack_path.to_json(),
'combat': self.combat.to_json(),
'stab_attack': self.stab_attack.to_json(),
'flyer_movement_mode_0x6ca56014': self.flyer_movement_mode_0x6ca56014.to_json(),
'flyer_movement_mode_0xe20e51c3': self.flyer_movement_mode_0xe20e51c3.to_json(),
'flyer_movement_mode_0x25a68a0e': self.flyer_movement_mode_0x25a68a0e.to_json(),
'flyer_movement_mode_0xd9b5d506': self.flyer_movement_mode_0xd9b5d506.to_json(),
'flyer_movement_mode_0x8bb1c3a2': self.flyer_movement_mode_0x8bb1c3a2.to_json(),
'stunned': self.stunned.to_json(),
'flyer_movement_mode_0xfb2ddfad': self.flyer_movement_mode_0xfb2ddfad.to_json(),
'dash': self.dash.to_json(),
'flyer_movement_mode_0x5fe13a7b': self.flyer_movement_mode_0x5fe13a7b.to_json(),
'claw': self.claw.to_json(),
'char_0x4d7dbeab': self.char_0x4d7dbeab.to_json(),
'char_0xa17c09bb': self.char_0xa17c09bb.to_json(),
'char_0x11dc2dab': self.char_0x11dc2dab.to_json(),
'char_0xfddd9abb': self.char_0xfddd9abb.to_json(),
'unknown_0xc99cee00': self.unknown_0xc99cee00,
'unknown_0x2ffc41e1': self.unknown_0x2ffc41e1,
'unknown_0x7f5d9ab7': self.unknown_0x7f5d9ab7,
'unknown_0x993d3556': self.unknown_0x993d3556,
'unknown_0x08efeb79': self.unknown_0x08efeb79,
'unknown_0xee8f4498': self.unknown_0xee8f4498,
'unknown_0xc24d8fbd': self.unknown_0xc24d8fbd,
'unknown_0x242d205c': self.unknown_0x242d205c,
'stun_threshold': self.stun_threshold,
'electric_ball_effect': self.electric_ball_effect,
'sound_ball_effect': self.sound_ball_effect,
'electric_visor_effect': self.electric_visor_effect,
'sound_visor_effect': self.sound_visor_effect,
'leg_hit_splash': self.leg_hit_splash,
}
def _decode_hearing_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lose_interest_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lose_interest_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfe4588a1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc2688b41(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7b0cc30d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_body_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_brain_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_brain_x_ray_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_brain_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_leg_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0xb9e0c90d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x81d39802(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_tentacle_regrow_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf79a10b0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc550a481(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x95e7a2c2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x76ba1c18(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe08106ed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x88d7c540(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xace62367(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x620b1b3d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attack_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_forward(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attack_forward(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0978b98a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcfcd32bb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x17d71349(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_recheck_path_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_recheck_path_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_num_metroids(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_auto_spawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_spawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_spawn_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6089191d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x258b5a9f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2ae610e5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hatch_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maya_double(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3fee1ba4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_spin_attack_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_damage': 30.0, 'di_knock_back_power': 20.0})
def _decode_max_spin_attack_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_spin_attack_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbeaf2105(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x54ff4d38(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb29fe2d9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dodge_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x42647ad7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa404d536(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x248d3599(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbfd77e62(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcdaa2c74(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2bca8395(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_patrol(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 3.0, 'acceleration': 1.0, 'facing_turn_rate': 30.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
def _decode_attack_path(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 3.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
def _decode_combat(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 3.0, 'acceleration': 10.0, 'turn_threshold': 181.0, 'floor_buffer': 11.0, 'ceiling_buffer': 8.0})
def _decode_stab_attack(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 0.10000000149011612, 'acceleration': 10.0, 'turn_rate': 10800.0, 'facing_turn_rate': 120.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 0.0, 'floor_buffer': 8.0, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0x6ca56014(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 30.0, 'acceleration': 50.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 0.0, 'floor_buffer': 3.5, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0xe20e51c3(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 30.0, 'acceleration': 10.0, 'facing_turn_rate': 1.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 1.0, 'floor_buffer': 5.0, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0x25a68a0e(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 1.0, 'acceleration': 10.0, 'turn_threshold': 181.0, 'height_variation_max': 0.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0xd9b5d506(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 30.0, 'acceleration': 20.0, 'facing_turn_rate': 1.0, 'turn_threshold': 181.0, 'height_variation_max': 1.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0x8bb1c3a2(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 1.0, 'acceleration': 10.0, 'turn_threshold': 181.0, 'height_variation_max': 1.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
def _decode_stunned(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 5.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_max': 1.0, 'floor_buffer': 5.0, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0xfb2ddfad(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 5.0, 'acceleration': 10.0, 'facing_turn_rate': 15.0, 'turn_threshold': 181.0, 'use_avoidance': False, 'height_variation_min': 1.0, 'floor_buffer': 10.0, 'ceiling_buffer': 8.0})
def _decode_dash(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'speed': 40.0, 'acceleration': 100.0, 'turn_rate': 360.0, 'turn_threshold': 181.0, 'avoidance_range': 1.0, 'height_variation_max': 0.5, 'floor_buffer': 13.0, 'ceiling_buffer': 8.0})
def _decode_flyer_movement_mode_0x5fe13a7b(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size, default_override={'acceleration': 20.0, 'turn_threshold': 181.0, 'floor_buffer': 12.0, 'ceiling_buffer': 12.0})
def _decode_claw(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_char_0x4d7dbeab(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_char_0xa17c09bb(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_char_0x11dc2dab(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_char_0xfddd9abb(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0xc99cee00(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2ffc41e1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7f5d9ab7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x993d3556(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x08efeb79(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xee8f4498(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc24d8fbd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x242d205c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stun_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_electric_ball_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound_ball_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_electric_visor_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound_visor_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_leg_hit_splash(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]]] = {
0x25474550: ('hearing_range', _decode_hearing_range),
0x474fa589: ('lose_interest_range', _decode_lose_interest_range),
0xf8b0c2bb: ('lose_interest_time', _decode_lose_interest_time),
0xfe4588a1: ('unknown_0xfe4588a1', _decode_unknown_0xfe4588a1),
0xc2688b41: ('unknown_0xc2688b41', _decode_unknown_0xc2688b41),
0x7b0cc30d: ('unknown_0x7b0cc30d', _decode_unknown_0x7b0cc30d),
0x742b3336: ('damage_vulnerability', _decode_damage_vulnerability),
0xd9230d1: ('body_vulnerability', _decode_body_vulnerability),
0x243ab10d: ('brain_vulnerability', _decode_brain_vulnerability),
0x12115a2: ('brain_x_ray_radius', _decode_brain_x_ray_radius),
0xa12a4409: ('brain_radius', _decode_brain_radius),
0x9f0ff852: ('leg_vulnerability', _decode_leg_vulnerability),
0xb9e0c90d: ('unknown_0xb9e0c90d', _decode_unknown_0xb9e0c90d),
0x81d39802: ('unknown_0x81d39802', _decode_unknown_0x81d39802),
0xba002dcb: ('tentacle_regrow_time', _decode_tentacle_regrow_time),
0xf79a10b0: ('unknown_0xf79a10b0', _decode_unknown_0xf79a10b0),
0xc550a481: ('unknown_0xc550a481', _decode_unknown_0xc550a481),
0x95e7a2c2: ('unknown_0x95e7a2c2', _decode_unknown_0x95e7a2c2),
0x76ba1c18: ('unknown_0x76ba1c18', _decode_unknown_0x76ba1c18),
0xe08106ed: ('unknown_0xe08106ed', _decode_unknown_0xe08106ed),
0x88d7c540: ('unknown_0x88d7c540', _decode_unknown_0x88d7c540),
0xace62367: ('unknown_0xace62367', _decode_unknown_0xace62367),
0x620b1b3d: ('unknown_0x620b1b3d', _decode_unknown_0x620b1b3d),
0xe1ae51d8: ('max_attack_height', _decode_max_attack_height),
0xc8d0acc0: ('min_attack_height', _decode_min_attack_height),
0xf3e8012d: ('max_attack_forward', _decode_max_attack_forward),
0xe0ade786: ('min_attack_forward', _decode_min_attack_forward),
0x978b98a: ('unknown_0x0978b98a', _decode_unknown_0x0978b98a),
0xcfcd32bb: ('unknown_0xcfcd32bb', _decode_unknown_0xcfcd32bb),
0x17d71349: ('unknown_0x17d71349', _decode_unknown_0x17d71349),
0x9aa90b6b: ('recheck_path_time', _decode_recheck_path_time),
0x7626ec89: ('recheck_path_distance', _decode_recheck_path_distance),
0x7915e2b3: ('max_num_metroids', _decode_max_num_metroids),
0xccc0cf92: ('auto_spawn', _decode_auto_spawn),
0x75e0b0a7: ('max_spawn_delay', _decode_max_spawn_delay),
0x2646a843: ('min_spawn_delay', _decode_min_spawn_delay),
0x6089191d: ('unknown_0x6089191d', _decode_unknown_0x6089191d),
0x258b5a9f: ('unknown_0x258b5a9f', _decode_unknown_0x258b5a9f),
0x2ae610e5: ('unknown_0x2ae610e5', _decode_unknown_0x2ae610e5),
0x354bae31: ('hatch_chance', _decode_hatch_chance),
0xf4b2c801: ('maya_double', _decode_maya_double),
0x3fee1ba4: ('unknown_0x3fee1ba4', _decode_unknown_0x3fee1ba4),
0xcfacff53: ('spin_attack_damage', _decode_spin_attack_damage),
0x6cb6d8c7: ('max_spin_attack_delay', _decode_max_spin_attack_delay),
0x682ce9ed: ('min_spin_attack_delay', _decode_min_spin_attack_delay),
0xbeaf2105: ('unknown_0xbeaf2105', _decode_unknown_0xbeaf2105),
0x54ff4d38: ('unknown_0x54ff4d38', _decode_unknown_0x54ff4d38),
0xb29fe2d9: ('unknown_0xb29fe2d9', _decode_unknown_0xb29fe2d9),
0x47be3298: ('dodge_chance', _decode_dodge_chance),
0x42647ad7: ('unknown_0x42647ad7', _decode_unknown_0x42647ad7),
0xa404d536: ('unknown_0xa404d536', _decode_unknown_0xa404d536),
0x248d3599: ('unknown_0x248d3599', _decode_unknown_0x248d3599),
0xbfd77e62: ('unknown_0xbfd77e62', _decode_unknown_0xbfd77e62),
0xcdaa2c74: ('unknown_0xcdaa2c74', _decode_unknown_0xcdaa2c74),
0x2bca8395: ('unknown_0x2bca8395', _decode_unknown_0x2bca8395),
0xccdd3aca: ('patrol', _decode_patrol),
0xc845d3c0: ('attack_path', _decode_attack_path),
0xcc7d2e98: ('combat', _decode_combat),
0xb9c3db94: ('stab_attack', _decode_stab_attack),
0x6ca56014: ('flyer_movement_mode_0x6ca56014', _decode_flyer_movement_mode_0x6ca56014),
0xe20e51c3: ('flyer_movement_mode_0xe20e51c3', _decode_flyer_movement_mode_0xe20e51c3),
0x25a68a0e: ('flyer_movement_mode_0x25a68a0e', _decode_flyer_movement_mode_0x25a68a0e),
0xd9b5d506: ('flyer_movement_mode_0xd9b5d506', _decode_flyer_movement_mode_0xd9b5d506),
0x8bb1c3a2: ('flyer_movement_mode_0x8bb1c3a2', _decode_flyer_movement_mode_0x8bb1c3a2),
0x389cb515: ('stunned', _decode_stunned),
0xfb2ddfad: ('flyer_movement_mode_0xfb2ddfad', _decode_flyer_movement_mode_0xfb2ddfad),
0xc558bc0d: ('dash', _decode_dash),
0x5fe13a7b: ('flyer_movement_mode_0x5fe13a7b', _decode_flyer_movement_mode_0x5fe13a7b),
0xfd38a106: ('claw', _decode_claw),
0x4d7dbeab: ('char_0x4d7dbeab', _decode_char_0x4d7dbeab),
0xa17c09bb: ('char_0xa17c09bb', _decode_char_0xa17c09bb),
0x11dc2dab: ('char_0x11dc2dab', _decode_char_0x11dc2dab),
0xfddd9abb: ('char_0xfddd9abb', _decode_char_0xfddd9abb),
0xc99cee00: ('unknown_0xc99cee00', _decode_unknown_0xc99cee00),
0x2ffc41e1: ('unknown_0x2ffc41e1', _decode_unknown_0x2ffc41e1),
0x7f5d9ab7: ('unknown_0x7f5d9ab7', _decode_unknown_0x7f5d9ab7),
0x993d3556: ('unknown_0x993d3556', _decode_unknown_0x993d3556),
0x8efeb79: ('unknown_0x08efeb79', _decode_unknown_0x08efeb79),
0xee8f4498: ('unknown_0xee8f4498', _decode_unknown_0xee8f4498),
0xc24d8fbd: ('unknown_0xc24d8fbd', _decode_unknown_0xc24d8fbd),
0x242d205c: ('unknown_0x242d205c', _decode_unknown_0x242d205c),
0x5bdd1e4c: ('stun_threshold', _decode_stun_threshold),
0x6da4a3b0: ('electric_ball_effect', _decode_electric_ball_effect),
0x3fcd8b66: ('sound_ball_effect', _decode_sound_ball_effect),
0xcc0af287: ('electric_visor_effect', _decode_electric_visor_effect),
0xa3e8ec4e: ('sound_visor_effect', _decode_sound_visor_effect),
0xf40a9c9d: ('leg_hit_splash', _decode_leg_hit_splash),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/MetroidHatcherData.py | 0.671363 | 0.164718 | MetroidHatcherData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Color import Color
@dataclasses.dataclass()
class UnknownStruct24(BaseProperty):
welding_tip: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
welding_torch: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
welding_beam: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0xea2c7744: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0x5a3ed5a0: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
start_weld: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
inside_collision: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
outside_collision: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part_0x5b468021: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
cmdl: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
weld_shatter: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0xbface762: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=0.0, b=0.0, a=0.0))
unknown_0x3761c8e8: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
weld_torch_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
weld_beam_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
inside_weld_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
outside_weld_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x1961d4a5: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
start_weld_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
weld_succeeded_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
weld_failed_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0x902d66f9: float = dataclasses.field(default=0.25)
unknown_0xedf4020e: float = dataclasses.field(default=0.4000000059604645)
unknown_0x9cf48efc: float = dataclasses.field(default=100.0)
welding_time: float = dataclasses.field(default=10.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x19') # 25 properties
data.write(b'j\xde\x8b\x91') # 0x6ade8b91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.welding_tip.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfb\xf9V\x9b') # 0xfbf9569b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.welding_torch))
data.write(b'\x8e\x14V{') # 0x8e14567b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.welding_beam))
data.write(b'\xea,wD') # 0xea2c7744
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.part_0xea2c7744))
data.write(b'Z>\xd5\xa0') # 0x5a3ed5a0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.part_0x5a3ed5a0))
data.write(b"p\xbe\xd4'") # 0x70bed427
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.start_weld))
data.write(b'\xac\xd3i\xc1') # 0xacd369c1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.inside_collision))
data.write(b'\x1d\xad\x13\xa3') # 0x1dad13a3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.outside_collision))
data.write(b'[F\x80!') # 0x5b468021
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.part_0x5b468021))
data.write(b'\xce\xca\xd2\xc3') # 0xcecad2c3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cmdl))
data.write(b'~T.\xaa') # 0x7e542eaa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.weld_shatter))
data.write(b'\xbf\xac\xe7b') # 0xbface762
data.write(b'\x00\x10') # size
self.unknown_0xbface762.to_stream(data)
data.write(b'7a\xc8\xe8') # 0x3761c8e8
data.write(b'\x00\x10') # size
self.unknown_0x3761c8e8.to_stream(data)
data.write(b'1\xc8\xbc\xaa') # 0x31c8bcaa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.weld_torch_sound))
data.write(b'\x1e\x1aI\xd5') # 0x1e1a49d5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.weld_beam_sound))
data.write(b'J\x8c\xf2\xf7') # 0x4a8cf2f7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.inside_weld_sound))
data.write(b'\xfb\xf2\x88\x95') # 0xfbf28895
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.outside_weld_sound))
data.write(b'\x19a\xd4\xa5') # 0x1961d4a5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x1961d4a5))
data.write(b'\x1f\xe9f\xf1') # 0x1fe966f1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.start_weld_sound))
data.write(b'}\xec\x1a\xef') # 0x7dec1aef
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.weld_succeeded_sound))
data.write(b'\xb3\xb5\xc8\xcb') # 0xb3b5c8cb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.weld_failed_sound))
data.write(b'\x90-f\xf9') # 0x902d66f9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x902d66f9))
data.write(b'\xed\xf4\x02\x0e') # 0xedf4020e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xedf4020e))
data.write(b'\x9c\xf4\x8e\xfc') # 0x9cf48efc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9cf48efc))
data.write(b'\xe6\x98\x94\x1f') # 0xe698941f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.welding_time))
@classmethod
def from_json(cls, data: dict):
return cls(
welding_tip=AnimationParameters.from_json(data['welding_tip']),
welding_torch=data['welding_torch'],
welding_beam=data['welding_beam'],
part_0xea2c7744=data['part_0xea2c7744'],
part_0x5a3ed5a0=data['part_0x5a3ed5a0'],
start_weld=data['start_weld'],
inside_collision=data['inside_collision'],
outside_collision=data['outside_collision'],
part_0x5b468021=data['part_0x5b468021'],
cmdl=data['cmdl'],
weld_shatter=data['weld_shatter'],
unknown_0xbface762=Color.from_json(data['unknown_0xbface762']),
unknown_0x3761c8e8=Color.from_json(data['unknown_0x3761c8e8']),
weld_torch_sound=data['weld_torch_sound'],
weld_beam_sound=data['weld_beam_sound'],
inside_weld_sound=data['inside_weld_sound'],
outside_weld_sound=data['outside_weld_sound'],
unknown_0x1961d4a5=data['unknown_0x1961d4a5'],
start_weld_sound=data['start_weld_sound'],
weld_succeeded_sound=data['weld_succeeded_sound'],
weld_failed_sound=data['weld_failed_sound'],
unknown_0x902d66f9=data['unknown_0x902d66f9'],
unknown_0xedf4020e=data['unknown_0xedf4020e'],
unknown_0x9cf48efc=data['unknown_0x9cf48efc'],
welding_time=data['welding_time'],
)
def to_json(self) -> dict:
return {
'welding_tip': self.welding_tip.to_json(),
'welding_torch': self.welding_torch,
'welding_beam': self.welding_beam,
'part_0xea2c7744': self.part_0xea2c7744,
'part_0x5a3ed5a0': self.part_0x5a3ed5a0,
'start_weld': self.start_weld,
'inside_collision': self.inside_collision,
'outside_collision': self.outside_collision,
'part_0x5b468021': self.part_0x5b468021,
'cmdl': self.cmdl,
'weld_shatter': self.weld_shatter,
'unknown_0xbface762': self.unknown_0xbface762.to_json(),
'unknown_0x3761c8e8': self.unknown_0x3761c8e8.to_json(),
'weld_torch_sound': self.weld_torch_sound,
'weld_beam_sound': self.weld_beam_sound,
'inside_weld_sound': self.inside_weld_sound,
'outside_weld_sound': self.outside_weld_sound,
'unknown_0x1961d4a5': self.unknown_0x1961d4a5,
'start_weld_sound': self.start_weld_sound,
'weld_succeeded_sound': self.weld_succeeded_sound,
'weld_failed_sound': self.weld_failed_sound,
'unknown_0x902d66f9': self.unknown_0x902d66f9,
'unknown_0xedf4020e': self.unknown_0xedf4020e,
'unknown_0x9cf48efc': self.unknown_0x9cf48efc,
'welding_time': self.welding_time,
}
def _decode_welding_tip(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_welding_torch(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_welding_beam(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_part_0xea2c7744(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_part_0x5a3ed5a0(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_start_weld(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_inside_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_outside_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_part_0x5b468021(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cmdl(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_weld_shatter(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xbface762(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0x3761c8e8(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_weld_torch_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_weld_beam_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_inside_weld_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_outside_weld_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x1961d4a5(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_start_weld_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_weld_succeeded_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_weld_failed_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x902d66f9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xedf4020e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9cf48efc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_welding_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]]] = {
0x6ade8b91: ('welding_tip', _decode_welding_tip),
0xfbf9569b: ('welding_torch', _decode_welding_torch),
0x8e14567b: ('welding_beam', _decode_welding_beam),
0xea2c7744: ('part_0xea2c7744', _decode_part_0xea2c7744),
0x5a3ed5a0: ('part_0x5a3ed5a0', _decode_part_0x5a3ed5a0),
0x70bed427: ('start_weld', _decode_start_weld),
0xacd369c1: ('inside_collision', _decode_inside_collision),
0x1dad13a3: ('outside_collision', _decode_outside_collision),
0x5b468021: ('part_0x5b468021', _decode_part_0x5b468021),
0xcecad2c3: ('cmdl', _decode_cmdl),
0x7e542eaa: ('weld_shatter', _decode_weld_shatter),
0xbface762: ('unknown_0xbface762', _decode_unknown_0xbface762),
0x3761c8e8: ('unknown_0x3761c8e8', _decode_unknown_0x3761c8e8),
0x31c8bcaa: ('weld_torch_sound', _decode_weld_torch_sound),
0x1e1a49d5: ('weld_beam_sound', _decode_weld_beam_sound),
0x4a8cf2f7: ('inside_weld_sound', _decode_inside_weld_sound),
0xfbf28895: ('outside_weld_sound', _decode_outside_weld_sound),
0x1961d4a5: ('unknown_0x1961d4a5', _decode_unknown_0x1961d4a5),
0x1fe966f1: ('start_weld_sound', _decode_start_weld_sound),
0x7dec1aef: ('weld_succeeded_sound', _decode_weld_succeeded_sound),
0xb3b5c8cb: ('weld_failed_sound', _decode_weld_failed_sound),
0x902d66f9: ('unknown_0x902d66f9', _decode_unknown_0x902d66f9),
0xedf4020e: ('unknown_0xedf4020e', _decode_unknown_0xedf4020e),
0x9cf48efc: ('unknown_0x9cf48efc', _decode_unknown_0x9cf48efc),
0xe698941f: ('welding_time', _decode_welding_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct24.py | 0.574037 | 0.156717 | UnknownStruct24.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class UnknownStruct31(BaseProperty):
initial_morph_time: float = dataclasses.field(default=15.0)
unknown_0xc8cfc063: float = dataclasses.field(default=15.0)
unknown_0x80c0d235: float = dataclasses.field(default=85.0)
unknown_0x26fa79a3: float = dataclasses.field(default=20.0)
unknown_0xc77f29dc: float = dataclasses.field(default=0.0)
gandrayda_to_berserker: float = dataclasses.field(default=20.0)
unknown_0xcbbd9a4e: float = dataclasses.field(default=40.0)
gandrayda_to_swarm: float = dataclasses.field(default=40.0)
unknown_0xa2675081: float = dataclasses.field(default=20.0)
unknown_0x413aee5b: float = dataclasses.field(default=30.0)
unknown_0x931ea2ea: float = dataclasses.field(default=10.0)
unknown_0x144f7ed6: float = dataclasses.field(default=45.0)
unknown_0x659d7d56: float = dataclasses.field(default=45.0)
unknown_0x7a11bb7b: float = dataclasses.field(default=60.0)
unknown_0xb4089be1: float = dataclasses.field(default=0.0)
swarm_to_gandrayda: float = dataclasses.field(default=90.0)
swarm_to_berserker: float = dataclasses.field(default=10.0)
unknown_0x73ac8586: float = dataclasses.field(default=60.0)
unknown_0x704c4fc6: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x13') # 19 properties
data.write(b'E\x16\x11\t') # 0x45161109
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_morph_time))
data.write(b'\xc8\xcf\xc0c') # 0xc8cfc063
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc8cfc063))
data.write(b'\x80\xc0\xd25') # 0x80c0d235
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x80c0d235))
data.write(b'&\xfay\xa3') # 0x26fa79a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x26fa79a3))
data.write(b'\xc7\x7f)\xdc') # 0xc77f29dc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc77f29dc))
data.write(b'\x14\x14s\xb5') # 0x141473b5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gandrayda_to_berserker))
data.write(b'\xcb\xbd\x9aN') # 0xcbbd9a4e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcbbd9a4e))
data.write(b'\x8d|a\x03') # 0x8d7c6103
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gandrayda_to_swarm))
data.write(b'\xa2gP\x81') # 0xa2675081
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa2675081))
data.write(b'A:\xee[') # 0x413aee5b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x413aee5b))
data.write(b'\x93\x1e\xa2\xea') # 0x931ea2ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x931ea2ea))
data.write(b'\x14O~\xd6') # 0x144f7ed6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x144f7ed6))
data.write(b'e\x9d}V') # 0x659d7d56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x659d7d56))
data.write(b'z\x11\xbb{') # 0x7a11bb7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7a11bb7b))
data.write(b'\xb4\x08\x9b\xe1') # 0xb4089be1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb4089be1))
data.write(b' #Z1') # 0x20235a31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swarm_to_gandrayda))
data.write(b'\xa7r\x86\r') # 0xa772860d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.swarm_to_berserker))
data.write(b's\xac\x85\x86') # 0x73ac8586
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x73ac8586))
data.write(b'pLO\xc6') # 0x704c4fc6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x704c4fc6))
@classmethod
def from_json(cls, data: dict):
return cls(
initial_morph_time=data['initial_morph_time'],
unknown_0xc8cfc063=data['unknown_0xc8cfc063'],
unknown_0x80c0d235=data['unknown_0x80c0d235'],
unknown_0x26fa79a3=data['unknown_0x26fa79a3'],
unknown_0xc77f29dc=data['unknown_0xc77f29dc'],
gandrayda_to_berserker=data['gandrayda_to_berserker'],
unknown_0xcbbd9a4e=data['unknown_0xcbbd9a4e'],
gandrayda_to_swarm=data['gandrayda_to_swarm'],
unknown_0xa2675081=data['unknown_0xa2675081'],
unknown_0x413aee5b=data['unknown_0x413aee5b'],
unknown_0x931ea2ea=data['unknown_0x931ea2ea'],
unknown_0x144f7ed6=data['unknown_0x144f7ed6'],
unknown_0x659d7d56=data['unknown_0x659d7d56'],
unknown_0x7a11bb7b=data['unknown_0x7a11bb7b'],
unknown_0xb4089be1=data['unknown_0xb4089be1'],
swarm_to_gandrayda=data['swarm_to_gandrayda'],
swarm_to_berserker=data['swarm_to_berserker'],
unknown_0x73ac8586=data['unknown_0x73ac8586'],
unknown_0x704c4fc6=data['unknown_0x704c4fc6'],
)
def to_json(self) -> dict:
return {
'initial_morph_time': self.initial_morph_time,
'unknown_0xc8cfc063': self.unknown_0xc8cfc063,
'unknown_0x80c0d235': self.unknown_0x80c0d235,
'unknown_0x26fa79a3': self.unknown_0x26fa79a3,
'unknown_0xc77f29dc': self.unknown_0xc77f29dc,
'gandrayda_to_berserker': self.gandrayda_to_berserker,
'unknown_0xcbbd9a4e': self.unknown_0xcbbd9a4e,
'gandrayda_to_swarm': self.gandrayda_to_swarm,
'unknown_0xa2675081': self.unknown_0xa2675081,
'unknown_0x413aee5b': self.unknown_0x413aee5b,
'unknown_0x931ea2ea': self.unknown_0x931ea2ea,
'unknown_0x144f7ed6': self.unknown_0x144f7ed6,
'unknown_0x659d7d56': self.unknown_0x659d7d56,
'unknown_0x7a11bb7b': self.unknown_0x7a11bb7b,
'unknown_0xb4089be1': self.unknown_0xb4089be1,
'swarm_to_gandrayda': self.swarm_to_gandrayda,
'swarm_to_berserker': self.swarm_to_berserker,
'unknown_0x73ac8586': self.unknown_0x73ac8586,
'unknown_0x704c4fc6': self.unknown_0x704c4fc6,
}
_FAST_FORMAT = None
_FAST_IDS = (0x45161109, 0xc8cfc063, 0x80c0d235, 0x26fa79a3, 0xc77f29dc, 0x141473b5, 0xcbbd9a4e, 0x8d7c6103, 0xa2675081, 0x413aee5b, 0x931ea2ea, 0x144f7ed6, 0x659d7d56, 0x7a11bb7b, 0xb4089be1, 0x20235a31, 0xa772860d, 0x73ac8586, 0x704c4fc6)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[UnknownStruct31]:
if property_count != 19:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(190))
if (dec[0], dec[3], dec[6], dec[9], dec[12], dec[15], dec[18], dec[21], dec[24], dec[27], dec[30], dec[33], dec[36], dec[39], dec[42], dec[45], dec[48], dec[51], dec[54]) != _FAST_IDS:
data.seek(before)
return None
return UnknownStruct31(
dec[2],
dec[5],
dec[8],
dec[11],
dec[14],
dec[17],
dec[20],
dec[23],
dec[26],
dec[29],
dec[32],
dec[35],
dec[38],
dec[41],
dec[44],
dec[47],
dec[50],
dec[53],
dec[56],
)
def _decode_initial_morph_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc8cfc063(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x80c0d235(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x26fa79a3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc77f29dc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gandrayda_to_berserker(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcbbd9a4e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gandrayda_to_swarm(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa2675081(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x413aee5b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x931ea2ea(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x144f7ed6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x659d7d56(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7a11bb7b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb4089be1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swarm_to_gandrayda(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_swarm_to_berserker(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x73ac8586(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x704c4fc6(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]]] = {
0x45161109: ('initial_morph_time', _decode_initial_morph_time),
0xc8cfc063: ('unknown_0xc8cfc063', _decode_unknown_0xc8cfc063),
0x80c0d235: ('unknown_0x80c0d235', _decode_unknown_0x80c0d235),
0x26fa79a3: ('unknown_0x26fa79a3', _decode_unknown_0x26fa79a3),
0xc77f29dc: ('unknown_0xc77f29dc', _decode_unknown_0xc77f29dc),
0x141473b5: ('gandrayda_to_berserker', _decode_gandrayda_to_berserker),
0xcbbd9a4e: ('unknown_0xcbbd9a4e', _decode_unknown_0xcbbd9a4e),
0x8d7c6103: ('gandrayda_to_swarm', _decode_gandrayda_to_swarm),
0xa2675081: ('unknown_0xa2675081', _decode_unknown_0xa2675081),
0x413aee5b: ('unknown_0x413aee5b', _decode_unknown_0x413aee5b),
0x931ea2ea: ('unknown_0x931ea2ea', _decode_unknown_0x931ea2ea),
0x144f7ed6: ('unknown_0x144f7ed6', _decode_unknown_0x144f7ed6),
0x659d7d56: ('unknown_0x659d7d56', _decode_unknown_0x659d7d56),
0x7a11bb7b: ('unknown_0x7a11bb7b', _decode_unknown_0x7a11bb7b),
0xb4089be1: ('unknown_0xb4089be1', _decode_unknown_0xb4089be1),
0x20235a31: ('swarm_to_gandrayda', _decode_swarm_to_gandrayda),
0xa772860d: ('swarm_to_berserker', _decode_swarm_to_berserker),
0x73ac8586: ('unknown_0x73ac8586', _decode_unknown_0x73ac8586),
0x704c4fc6: ('unknown_0x704c4fc6', _decode_unknown_0x704c4fc6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/UnknownStruct31.py | 0.563858 | 0.274245 | UnknownStruct31.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.FlyerMovementMode import FlyerMovementMode
from retro_data_structures.properties.corruption.archetypes.LaunchProjectileData import LaunchProjectileData
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PhazonHarvesterData(BaseProperty):
starts_flying: bool = dataclasses.field(default=True)
weapon_projectile: LaunchProjectileData = dataclasses.field(default_factory=LaunchProjectileData)
weapon_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
weapon_stun_damage: float = dataclasses.field(default=20.0)
unknown_0x6b554a8d: float = dataclasses.field(default=4.0)
unknown_0x08772297: float = dataclasses.field(default=2.0)
unknown_0xee178d76: float = dataclasses.field(default=6.0)
weapon_max_pitch: float = dataclasses.field(default=0.0)
weapon_min_pitch: float = dataclasses.field(default=-90.0)
max_weapon_rotation: float = dataclasses.field(default=70.0)
weapon_rotation_speed: float = dataclasses.field(default=90.0)
hatch_open_time: float = dataclasses.field(default=2.0)
hatch_close_time: float = dataclasses.field(default=2.0)
flight_normal: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
flight_attack: FlyerMovementMode = dataclasses.field(default_factory=FlyerMovementMode)
weapon_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
left_front_hatch_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
left_back_hatch_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
right_fron_hatch_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
right_back_hatch_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x14') # 20 properties
data.write(b'\x1c\xe8\xf49') # 0x1ce8f439
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.starts_flying))
data.write(b' 6\x07\x7f') # 0x2036077f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weapon_projectile.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xae"\xe0\xdc') # 0xae22e0dc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weapon_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'O\xdc\x16\x83') # 0x4fdc1683
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.weapon_stun_damage))
data.write(b'kUJ\x8d') # 0x6b554a8d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6b554a8d))
data.write(b'\x08w"\x97') # 0x8772297
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x08772297))
data.write(b'\xee\x17\x8dv') # 0xee178d76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xee178d76))
data.write(b'u`\x8e\xd3') # 0x75608ed3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.weapon_max_pitch))
data.write(b'5/\xf6\xa5') # 0x352ff6a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.weapon_min_pitch))
data.write(b'\xcd\x8a\xb1\xe3') # 0xcd8ab1e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_weapon_rotation))
data.write(b'\xf0\xe6M\x85') # 0xf0e64d85
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.weapon_rotation_speed))
data.write(b'+4I\xf5') # 0x2b3449f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hatch_open_time))
data.write(b'\x1d\xd9\xe8\xbf') # 0x1dd9e8bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hatch_close_time))
data.write(b'\x13\x0c\xf1\xa1') # 0x130cf1a1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_normal.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfcQ\xdf\x90') # 0xfc51df90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flight_attack.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'z\x15NI') # 0x7a154e49
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.weapon_model))
data.write(b'\xc7Bk\x90') # 0xc7426b90
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_front_hatch_model))
data.write(b'\xe2\xef\xee\x98') # 0xe2efee98
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.left_back_hatch_model))
data.write(b'\x15[\xf2K') # 0x155bf24b
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_fron_hatch_model))
data.write(b'\xd7W\xcb\x94') # 0xd757cb94
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.right_back_hatch_model))
@classmethod
def from_json(cls, data: dict):
return cls(
starts_flying=data['starts_flying'],
weapon_projectile=LaunchProjectileData.from_json(data['weapon_projectile']),
weapon_vulnerability=DamageVulnerability.from_json(data['weapon_vulnerability']),
weapon_stun_damage=data['weapon_stun_damage'],
unknown_0x6b554a8d=data['unknown_0x6b554a8d'],
unknown_0x08772297=data['unknown_0x08772297'],
unknown_0xee178d76=data['unknown_0xee178d76'],
weapon_max_pitch=data['weapon_max_pitch'],
weapon_min_pitch=data['weapon_min_pitch'],
max_weapon_rotation=data['max_weapon_rotation'],
weapon_rotation_speed=data['weapon_rotation_speed'],
hatch_open_time=data['hatch_open_time'],
hatch_close_time=data['hatch_close_time'],
flight_normal=FlyerMovementMode.from_json(data['flight_normal']),
flight_attack=FlyerMovementMode.from_json(data['flight_attack']),
weapon_model=data['weapon_model'],
left_front_hatch_model=data['left_front_hatch_model'],
left_back_hatch_model=data['left_back_hatch_model'],
right_fron_hatch_model=data['right_fron_hatch_model'],
right_back_hatch_model=data['right_back_hatch_model'],
)
def to_json(self) -> dict:
return {
'starts_flying': self.starts_flying,
'weapon_projectile': self.weapon_projectile.to_json(),
'weapon_vulnerability': self.weapon_vulnerability.to_json(),
'weapon_stun_damage': self.weapon_stun_damage,
'unknown_0x6b554a8d': self.unknown_0x6b554a8d,
'unknown_0x08772297': self.unknown_0x08772297,
'unknown_0xee178d76': self.unknown_0xee178d76,
'weapon_max_pitch': self.weapon_max_pitch,
'weapon_min_pitch': self.weapon_min_pitch,
'max_weapon_rotation': self.max_weapon_rotation,
'weapon_rotation_speed': self.weapon_rotation_speed,
'hatch_open_time': self.hatch_open_time,
'hatch_close_time': self.hatch_close_time,
'flight_normal': self.flight_normal.to_json(),
'flight_attack': self.flight_attack.to_json(),
'weapon_model': self.weapon_model,
'left_front_hatch_model': self.left_front_hatch_model,
'left_back_hatch_model': self.left_back_hatch_model,
'right_fron_hatch_model': self.right_fron_hatch_model,
'right_back_hatch_model': self.right_back_hatch_model,
}
def _decode_starts_flying(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_weapon_projectile(data: typing.BinaryIO, property_size: int):
return LaunchProjectileData.from_stream(data, property_size)
def _decode_weapon_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_weapon_stun_damage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6b554a8d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x08772297(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xee178d76(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_weapon_max_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_weapon_min_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_weapon_rotation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_weapon_rotation_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hatch_open_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hatch_close_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flight_normal(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_flight_attack(data: typing.BinaryIO, property_size: int):
return FlyerMovementMode.from_stream(data, property_size)
def _decode_weapon_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_front_hatch_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_left_back_hatch_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_fron_hatch_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_right_back_hatch_model(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]]] = {
0x1ce8f439: ('starts_flying', _decode_starts_flying),
0x2036077f: ('weapon_projectile', _decode_weapon_projectile),
0xae22e0dc: ('weapon_vulnerability', _decode_weapon_vulnerability),
0x4fdc1683: ('weapon_stun_damage', _decode_weapon_stun_damage),
0x6b554a8d: ('unknown_0x6b554a8d', _decode_unknown_0x6b554a8d),
0x8772297: ('unknown_0x08772297', _decode_unknown_0x08772297),
0xee178d76: ('unknown_0xee178d76', _decode_unknown_0xee178d76),
0x75608ed3: ('weapon_max_pitch', _decode_weapon_max_pitch),
0x352ff6a5: ('weapon_min_pitch', _decode_weapon_min_pitch),
0xcd8ab1e3: ('max_weapon_rotation', _decode_max_weapon_rotation),
0xf0e64d85: ('weapon_rotation_speed', _decode_weapon_rotation_speed),
0x2b3449f5: ('hatch_open_time', _decode_hatch_open_time),
0x1dd9e8bf: ('hatch_close_time', _decode_hatch_close_time),
0x130cf1a1: ('flight_normal', _decode_flight_normal),
0xfc51df90: ('flight_attack', _decode_flight_attack),
0x7a154e49: ('weapon_model', _decode_weapon_model),
0xc7426b90: ('left_front_hatch_model', _decode_left_front_hatch_model),
0xe2efee98: ('left_back_hatch_model', _decode_left_back_hatch_model),
0x155bf24b: ('right_fron_hatch_model', _decode_right_fron_hatch_model),
0xd757cb94: ('right_back_hatch_model', _decode_right_back_hatch_model),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/PhazonHarvesterData.py | 0.555194 | 0.18984 | PhazonHarvesterData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.HoverThenHomeProjectile import HoverThenHomeProjectile
from retro_data_structures.properties.corruption.archetypes.LaunchProjectileData import LaunchProjectileData
from retro_data_structures.properties.corruption.archetypes.PlasmaBeamInfo import PlasmaBeamInfo
from retro_data_structures.properties.corruption.archetypes.UnknownStruct37 import UnknownStruct37
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class GhorStructB(BaseProperty):
mini_gun_projectile: LaunchProjectileData = dataclasses.field(default_factory=LaunchProjectileData)
beam_info: PlasmaBeamInfo = dataclasses.field(default_factory=PlasmaBeamInfo)
beam_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
beam_constraint_angle: float = dataclasses.field(default=30.0)
charge_attack_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
missile_hover_then_home_projectile: HoverThenHomeProjectile = dataclasses.field(default_factory=HoverThenHomeProjectile)
missile_projectile: LaunchProjectileData = dataclasses.field(default_factory=LaunchProjectileData)
unknown_0x63fee872: float = dataclasses.field(default=10.0)
missile_collision_size: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_0x1ba35af4: float = dataclasses.field(default=1.0)
unknown_struct37: UnknownStruct37 = dataclasses.field(default_factory=UnknownStruct37)
melee_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0c') # 12 properties
data.write(b'\x07\x8a\x03\xd9') # 0x78a03d9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mini_gun_projectile.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\x98\x01*') # 0x1598012a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x13\xe3\x0eM') # 0x13e30e4d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'L\xac\xfa\xe3') # 0x4cacfae3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.beam_constraint_angle))
data.write(b'\xe7\x9e\xcf\xd4') # 0xe79ecfd4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.charge_attack_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'`;\xfd!') # 0x603bfd21
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.missile_hover_then_home_projectile.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8fMT\xf9') # 0x8f4d54f9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.missile_projectile.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c\xfe\xe8r') # 0x63fee872
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x63fee872))
data.write(b'\xa2\xf2\x16\x8c') # 0xa2f2168c
data.write(b'\x00\x0c') # size
self.missile_collision_size.to_stream(data)
data.write(b'\x1b\xa3Z\xf4') # 0x1ba35af4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1ba35af4))
data.write(b'\xda\xe2\x13t') # 0xdae21374
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct37.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9A`4') # 0xc9416034
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.melee_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
mini_gun_projectile=LaunchProjectileData.from_json(data['mini_gun_projectile']),
beam_info=PlasmaBeamInfo.from_json(data['beam_info']),
beam_damage=DamageInfo.from_json(data['beam_damage']),
beam_constraint_angle=data['beam_constraint_angle'],
charge_attack_damage=DamageInfo.from_json(data['charge_attack_damage']),
missile_hover_then_home_projectile=HoverThenHomeProjectile.from_json(data['missile_hover_then_home_projectile']),
missile_projectile=LaunchProjectileData.from_json(data['missile_projectile']),
unknown_0x63fee872=data['unknown_0x63fee872'],
missile_collision_size=Vector.from_json(data['missile_collision_size']),
unknown_0x1ba35af4=data['unknown_0x1ba35af4'],
unknown_struct37=UnknownStruct37.from_json(data['unknown_struct37']),
melee_damage=DamageInfo.from_json(data['melee_damage']),
)
def to_json(self) -> dict:
return {
'mini_gun_projectile': self.mini_gun_projectile.to_json(),
'beam_info': self.beam_info.to_json(),
'beam_damage': self.beam_damage.to_json(),
'beam_constraint_angle': self.beam_constraint_angle,
'charge_attack_damage': self.charge_attack_damage.to_json(),
'missile_hover_then_home_projectile': self.missile_hover_then_home_projectile.to_json(),
'missile_projectile': self.missile_projectile.to_json(),
'unknown_0x63fee872': self.unknown_0x63fee872,
'missile_collision_size': self.missile_collision_size.to_json(),
'unknown_0x1ba35af4': self.unknown_0x1ba35af4,
'unknown_struct37': self.unknown_struct37.to_json(),
'melee_damage': self.melee_damage.to_json(),
}
def _decode_mini_gun_projectile(data: typing.BinaryIO, property_size: int):
return LaunchProjectileData.from_stream(data, property_size)
def _decode_beam_info(data: typing.BinaryIO, property_size: int):
return PlasmaBeamInfo.from_stream(data, property_size)
def _decode_beam_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_beam_constraint_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_charge_attack_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_missile_hover_then_home_projectile(data: typing.BinaryIO, property_size: int):
return HoverThenHomeProjectile.from_stream(data, property_size)
def _decode_missile_projectile(data: typing.BinaryIO, property_size: int):
return LaunchProjectileData.from_stream(data, property_size)
def _decode_unknown_0x63fee872(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_missile_collision_size(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x1ba35af4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct37(data: typing.BinaryIO, property_size: int):
return UnknownStruct37.from_stream(data, property_size)
def _decode_melee_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x78a03d9: ('mini_gun_projectile', _decode_mini_gun_projectile),
0x1598012a: ('beam_info', _decode_beam_info),
0x13e30e4d: ('beam_damage', _decode_beam_damage),
0x4cacfae3: ('beam_constraint_angle', _decode_beam_constraint_angle),
0xe79ecfd4: ('charge_attack_damage', _decode_charge_attack_damage),
0x603bfd21: ('missile_hover_then_home_projectile', _decode_missile_hover_then_home_projectile),
0x8f4d54f9: ('missile_projectile', _decode_missile_projectile),
0x63fee872: ('unknown_0x63fee872', _decode_unknown_0x63fee872),
0xa2f2168c: ('missile_collision_size', _decode_missile_collision_size),
0x1ba35af4: ('unknown_0x1ba35af4', _decode_unknown_0x1ba35af4),
0xdae21374: ('unknown_struct37', _decode_unknown_struct37),
0xc9416034: ('melee_damage', _decode_melee_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/GhorStructB.py | 0.490236 | 0.346044 | GhorStructB.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.archetypes.InterpolationMethod import InterpolationMethod
from retro_data_structures.properties.corruption.archetypes.NonSlowdown import NonSlowdown
@dataclasses.dataclass()
class MotionInterpolationMethod(BaseProperty):
motion_type: enums.MotionType = dataclasses.field(default=enums.MotionType.Unknown2)
non_slowdown: NonSlowdown = dataclasses.field(default_factory=NonSlowdown)
motion_control: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'\x94\x8a\xf5q') # 0x948af571
data.write(b'\x00\x04') # size
self.motion_type.to_stream(data)
data.write(b'y\xdeK\xa5') # 0x79de4ba5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.non_slowdown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x7f\x9fE') # 0x287f9f45
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
motion_type=enums.MotionType.from_json(data['motion_type']),
non_slowdown=NonSlowdown.from_json(data['non_slowdown']),
motion_control=InterpolationMethod.from_json(data['motion_control']),
)
def to_json(self) -> dict:
return {
'motion_type': self.motion_type.to_json(),
'non_slowdown': self.non_slowdown.to_json(),
'motion_control': self.motion_control.to_json(),
}
def _decode_motion_type(data: typing.BinaryIO, property_size: int):
return enums.MotionType.from_stream(data)
def _decode_non_slowdown(data: typing.BinaryIO, property_size: int):
return NonSlowdown.from_stream(data, property_size)
def _decode_motion_control(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x948af571: ('motion_type', _decode_motion_type),
0x79de4ba5: ('non_slowdown', _decode_non_slowdown),
0x287f9f45: ('motion_control', _decode_motion_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/MotionInterpolationMethod.py | 0.619356 | 0.259896 | MotionInterpolationMethod.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.ModIncaData import ModIncaData
@dataclasses.dataclass()
class PhazonLeechData(BaseProperty):
energy_loss: float = dataclasses.field(default=1.0)
min_hunger_energy: float = dataclasses.field(default=0.5)
hunger_threshold: float = dataclasses.field(default=0.699999988079071)
bored_threshold: float = dataclasses.field(default=0.8999999761581421)
unknown_0xa822c334: float = dataclasses.field(default=0.15000000596046448)
alert_time: float = dataclasses.field(default=30.0)
unknown_0x61634792: float = dataclasses.field(default=35.0)
unknown_0xc657c7eb: float = dataclasses.field(default=55.0)
min_attach_time: float = dataclasses.field(default=2.0)
max_attach_time: float = dataclasses.field(default=4.0)
jump_position_offset: float = dataclasses.field(default=-1.0)
attach_position_offset: float = dataclasses.field(default=-1.0)
unknown_0x4f547915: float = dataclasses.field(default=2.0)
unknown_0xa934d6f4: float = dataclasses.field(default=1.0)
normal_jump_apex: float = dataclasses.field(default=3.0)
normal_jump_speed: float = dataclasses.field(default=1.0)
attack_jump_apex: float = dataclasses.field(default=1.0)
attack_jump_speed: float = dataclasses.field(default=1.0)
detach_jump_apex: float = dataclasses.field(default=2.0)
detach_jump_speed: float = dataclasses.field(default=1.0)
hurl_distance: float = dataclasses.field(default=7.0)
attach_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
attach_damage_delay: float = dataclasses.field(default=0.5)
unknown_0x57fee02a: float = dataclasses.field(default=0.10000000149011612)
mod_inca_data: ModIncaData = dataclasses.field(default_factory=ModIncaData)
use_terrain_alignment: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x1a') # 26 properties
data.write(b'P\xd4\xe6\xdd') # 0x50d4e6dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.energy_loss))
data.write(b'F8\x01O') # 0x4638014f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_hunger_energy))
data.write(b'\xfeA\xf1\xab') # 0xfe41f1ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hunger_threshold))
data.write(b'\x96r\x9b\x15') # 0x96729b15
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bored_threshold))
data.write(b'\xa8"\xc34') # 0xa822c334
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa822c334))
data.write(b'\xd2c\x97|') # 0xd263977c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alert_time))
data.write(b'acG\x92') # 0x61634792
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61634792))
data.write(b'\xc6W\xc7\xeb') # 0xc657c7eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc657c7eb))
data.write(b'\xc5\xe8\x88k') # 0xc5e8886b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_attach_time))
data.write(b'\x96N\x90\x8f') # 0x964e908f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attach_time))
data.write(b'\xc9\xdbC\xb2') # 0xc9db43b2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_position_offset))
data.write(b'7\x15\x94\xcd') # 0x371594cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attach_position_offset))
data.write(b'OTy\x15') # 0x4f547915
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4f547915))
data.write(b'\xa94\xd6\xf4') # 0xa934d6f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa934d6f4))
data.write(b'2\xab-\x0f') # 0x32ab2d0f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_jump_apex))
data.write(b'\xcaQr\x18') # 0xca517218
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_jump_speed))
data.write(b'o\x1d\xeb&') # 0x6f1deb26
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_jump_apex))
data.write(b'\x88\xbe\\\xb2') # 0x88be5cb2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_jump_speed))
data.write(b'\xec\x07\xa9\xbe') # 0xec07a9be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detach_jump_apex))
data.write(b'v\xe9]\x86') # 0x76e95d86
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detach_jump_speed))
data.write(b'\x13\xbf\xc5\xdd') # 0x13bfc5dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_distance))
data.write(b'5F\xf1O') # 0x3546f14f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attach_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89v\xd3\xf6') # 0x8976d3f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attach_damage_delay))
data.write(b'W\xfe\xe0*') # 0x57fee02a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x57fee02a))
data.write(b'\xb4\xc0(T') # 0xb4c02854
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mod_inca_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\x17\xe7\x8f') # 0x6117e78f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_terrain_alignment))
@classmethod
def from_json(cls, data: dict):
return cls(
energy_loss=data['energy_loss'],
min_hunger_energy=data['min_hunger_energy'],
hunger_threshold=data['hunger_threshold'],
bored_threshold=data['bored_threshold'],
unknown_0xa822c334=data['unknown_0xa822c334'],
alert_time=data['alert_time'],
unknown_0x61634792=data['unknown_0x61634792'],
unknown_0xc657c7eb=data['unknown_0xc657c7eb'],
min_attach_time=data['min_attach_time'],
max_attach_time=data['max_attach_time'],
jump_position_offset=data['jump_position_offset'],
attach_position_offset=data['attach_position_offset'],
unknown_0x4f547915=data['unknown_0x4f547915'],
unknown_0xa934d6f4=data['unknown_0xa934d6f4'],
normal_jump_apex=data['normal_jump_apex'],
normal_jump_speed=data['normal_jump_speed'],
attack_jump_apex=data['attack_jump_apex'],
attack_jump_speed=data['attack_jump_speed'],
detach_jump_apex=data['detach_jump_apex'],
detach_jump_speed=data['detach_jump_speed'],
hurl_distance=data['hurl_distance'],
attach_damage=DamageInfo.from_json(data['attach_damage']),
attach_damage_delay=data['attach_damage_delay'],
unknown_0x57fee02a=data['unknown_0x57fee02a'],
mod_inca_data=ModIncaData.from_json(data['mod_inca_data']),
use_terrain_alignment=data['use_terrain_alignment'],
)
def to_json(self) -> dict:
return {
'energy_loss': self.energy_loss,
'min_hunger_energy': self.min_hunger_energy,
'hunger_threshold': self.hunger_threshold,
'bored_threshold': self.bored_threshold,
'unknown_0xa822c334': self.unknown_0xa822c334,
'alert_time': self.alert_time,
'unknown_0x61634792': self.unknown_0x61634792,
'unknown_0xc657c7eb': self.unknown_0xc657c7eb,
'min_attach_time': self.min_attach_time,
'max_attach_time': self.max_attach_time,
'jump_position_offset': self.jump_position_offset,
'attach_position_offset': self.attach_position_offset,
'unknown_0x4f547915': self.unknown_0x4f547915,
'unknown_0xa934d6f4': self.unknown_0xa934d6f4,
'normal_jump_apex': self.normal_jump_apex,
'normal_jump_speed': self.normal_jump_speed,
'attack_jump_apex': self.attack_jump_apex,
'attack_jump_speed': self.attack_jump_speed,
'detach_jump_apex': self.detach_jump_apex,
'detach_jump_speed': self.detach_jump_speed,
'hurl_distance': self.hurl_distance,
'attach_damage': self.attach_damage.to_json(),
'attach_damage_delay': self.attach_damage_delay,
'unknown_0x57fee02a': self.unknown_0x57fee02a,
'mod_inca_data': self.mod_inca_data.to_json(),
'use_terrain_alignment': self.use_terrain_alignment,
}
def _decode_energy_loss(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_hunger_energy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hunger_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bored_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa822c334(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alert_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x61634792(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc657c7eb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_attach_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attach_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_jump_position_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attach_position_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4f547915(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa934d6f4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_normal_jump_apex(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_normal_jump_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_jump_apex(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_jump_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detach_jump_apex(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detach_jump_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hurl_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attach_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_attach_damage_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x57fee02a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mod_inca_data(data: typing.BinaryIO, property_size: int):
return ModIncaData.from_stream(data, property_size)
def _decode_use_terrain_alignment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x50d4e6dd: ('energy_loss', _decode_energy_loss),
0x4638014f: ('min_hunger_energy', _decode_min_hunger_energy),
0xfe41f1ab: ('hunger_threshold', _decode_hunger_threshold),
0x96729b15: ('bored_threshold', _decode_bored_threshold),
0xa822c334: ('unknown_0xa822c334', _decode_unknown_0xa822c334),
0xd263977c: ('alert_time', _decode_alert_time),
0x61634792: ('unknown_0x61634792', _decode_unknown_0x61634792),
0xc657c7eb: ('unknown_0xc657c7eb', _decode_unknown_0xc657c7eb),
0xc5e8886b: ('min_attach_time', _decode_min_attach_time),
0x964e908f: ('max_attach_time', _decode_max_attach_time),
0xc9db43b2: ('jump_position_offset', _decode_jump_position_offset),
0x371594cd: ('attach_position_offset', _decode_attach_position_offset),
0x4f547915: ('unknown_0x4f547915', _decode_unknown_0x4f547915),
0xa934d6f4: ('unknown_0xa934d6f4', _decode_unknown_0xa934d6f4),
0x32ab2d0f: ('normal_jump_apex', _decode_normal_jump_apex),
0xca517218: ('normal_jump_speed', _decode_normal_jump_speed),
0x6f1deb26: ('attack_jump_apex', _decode_attack_jump_apex),
0x88be5cb2: ('attack_jump_speed', _decode_attack_jump_speed),
0xec07a9be: ('detach_jump_apex', _decode_detach_jump_apex),
0x76e95d86: ('detach_jump_speed', _decode_detach_jump_speed),
0x13bfc5dd: ('hurl_distance', _decode_hurl_distance),
0x3546f14f: ('attach_damage', _decode_attach_damage),
0x8976d3f6: ('attach_damage_delay', _decode_attach_damage_delay),
0x57fee02a: ('unknown_0x57fee02a', _decode_unknown_0x57fee02a),
0xb4c02854: ('mod_inca_data', _decode_mod_inca_data),
0x6117e78f: ('use_terrain_alignment', _decode_use_terrain_alignment),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/PhazonLeechData.py | 0.617513 | 0.282784 | PhazonLeechData.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.TGunResources import TGunResources
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class TBallTransitionResources(BaseProperty):
unknown_0xd48e4124: str = dataclasses.field(default='')
unknown_0x01e12c84: TGunResources = dataclasses.field(default_factory=TGunResources)
unknown_0xf24b055d: TGunResources = dataclasses.field(default_factory=TGunResources)
unknown_0xa342c3a6: Spline = dataclasses.field(default_factory=Spline)
unknown_0x15b6840d: Spline = dataclasses.field(default_factory=Spline)
unknown_0x23fb0e93: Spline = dataclasses.field(default_factory=Spline)
unknown_0x564262f0: Spline = dataclasses.field(default_factory=Spline)
movement_control: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x08') # 8 properties
data.write(b'\xd4\x8eA$') # 0xd48e4124
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xd48e4124.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'\x01\xe1,\x84') # 0x1e12c84
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x01e12c84.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf2K\x05]') # 0xf24b055d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xf24b055d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa3B\xc3\xa6') # 0xa342c3a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xa342c3a6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\xb6\x84\r') # 0x15b6840d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x15b6840d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#\xfb\x0e\x93') # 0x23fb0e93
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x23fb0e93.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'VBb\xf0') # 0x564262f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x564262f0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\x83\xa2b') # 0x9183a262
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.movement_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_0xd48e4124=data['unknown_0xd48e4124'],
unknown_0x01e12c84=TGunResources.from_json(data['unknown_0x01e12c84']),
unknown_0xf24b055d=TGunResources.from_json(data['unknown_0xf24b055d']),
unknown_0xa342c3a6=Spline.from_json(data['unknown_0xa342c3a6']),
unknown_0x15b6840d=Spline.from_json(data['unknown_0x15b6840d']),
unknown_0x23fb0e93=Spline.from_json(data['unknown_0x23fb0e93']),
unknown_0x564262f0=Spline.from_json(data['unknown_0x564262f0']),
movement_control=Spline.from_json(data['movement_control']),
)
def to_json(self) -> dict:
return {
'unknown_0xd48e4124': self.unknown_0xd48e4124,
'unknown_0x01e12c84': self.unknown_0x01e12c84.to_json(),
'unknown_0xf24b055d': self.unknown_0xf24b055d.to_json(),
'unknown_0xa342c3a6': self.unknown_0xa342c3a6.to_json(),
'unknown_0x15b6840d': self.unknown_0x15b6840d.to_json(),
'unknown_0x23fb0e93': self.unknown_0x23fb0e93.to_json(),
'unknown_0x564262f0': self.unknown_0x564262f0.to_json(),
'movement_control': self.movement_control.to_json(),
}
def _decode_unknown_0xd48e4124(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x01e12c84(data: typing.BinaryIO, property_size: int):
return TGunResources.from_stream(data, property_size)
def _decode_unknown_0xf24b055d(data: typing.BinaryIO, property_size: int):
return TGunResources.from_stream(data, property_size)
def _decode_unknown_0xa342c3a6(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x15b6840d(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x23fb0e93(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_unknown_0x564262f0(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_movement_control(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xd48e4124: ('unknown_0xd48e4124', _decode_unknown_0xd48e4124),
0x1e12c84: ('unknown_0x01e12c84', _decode_unknown_0x01e12c84),
0xf24b055d: ('unknown_0xf24b055d', _decode_unknown_0xf24b055d),
0xa342c3a6: ('unknown_0xa342c3a6', _decode_unknown_0xa342c3a6),
0x15b6840d: ('unknown_0x15b6840d', _decode_unknown_0x15b6840d),
0x23fb0e93: ('unknown_0x23fb0e93', _decode_unknown_0x23fb0e93),
0x564262f0: ('unknown_0x564262f0', _decode_unknown_0x564262f0),
0x9183a262: ('movement_control', _decode_movement_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/TBallTransitionResources.py | 0.502197 | 0.281066 | TBallTransitionResources.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.archetypes.PathDeterminationMethodType import PathDeterminationMethodType
@dataclasses.dataclass()
class PathDetermination(BaseProperty):
path_link_type: enums.PathLinkType = dataclasses.field(default=enums.PathLinkType.Unknown3)
path_determination_method_type: PathDeterminationMethodType = dataclasses.field(default_factory=PathDeterminationMethodType)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'U\x95B\xab') # 0x559542ab
data.write(b'\x00\x04') # size
self.path_link_type.to_stream(data)
data.write(b'API\x0c') # 0x4150490c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_determination_method_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
path_link_type=enums.PathLinkType.from_json(data['path_link_type']),
path_determination_method_type=PathDeterminationMethodType.from_json(data['path_determination_method_type']),
)
def to_json(self) -> dict:
return {
'path_link_type': self.path_link_type.to_json(),
'path_determination_method_type': self.path_determination_method_type.to_json(),
}
def _decode_path_link_type(data: typing.BinaryIO, property_size: int):
return enums.PathLinkType.from_stream(data)
def _decode_path_determination_method_type(data: typing.BinaryIO, property_size: int):
return PathDeterminationMethodType.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x559542ab: ('path_link_type', _decode_path_link_type),
0x4150490c: ('path_determination_method_type', _decode_path_determination_method_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/PathDetermination.py | 0.602179 | 0.293677 | PathDetermination.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class TranslationSplines(BaseProperty):
x_translation: Spline = dataclasses.field(default_factory=Spline)
y_translation: Spline = dataclasses.field(default_factory=Spline)
z_translation: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x03') # 3 properties
data.write(b'$\xe9\xa0\x9b') # 0x24e9a09b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.x_translation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\xbb\x16z') # 0xcbbb167a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.y_translation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!=\xcb\x18') # 0x213dcb18
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.z_translation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
x_translation=Spline.from_json(data['x_translation']),
y_translation=Spline.from_json(data['y_translation']),
z_translation=Spline.from_json(data['z_translation']),
)
def to_json(self) -> dict:
return {
'x_translation': self.x_translation.to_json(),
'y_translation': self.y_translation.to_json(),
'z_translation': self.z_translation.to_json(),
}
def _decode_x_translation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_y_translation(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_z_translation(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]]] = {
0x24e9a09b: ('x_translation', _decode_x_translation),
0xcbbb167a: ('y_translation', _decode_y_translation),
0x213dcb18: ('z_translation', _decode_z_translation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/TranslationSplines.py | 0.636805 | 0.312436 | TranslationSplines.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.archetypes.Convergence import Convergence
from retro_data_structures.properties.corruption.archetypes.OffsetSplines import OffsetSplines
from retro_data_structures.properties.corruption.archetypes.PathDetermination import PathDetermination
from retro_data_structures.properties.corruption.archetypes.SpindleOrientation import SpindleOrientation
from retro_data_structures.properties.corruption.archetypes.SurfaceOrientation import SurfaceOrientation
from retro_data_structures.properties.corruption.archetypes.UnknownStruct23 import UnknownStruct23
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class CameraOrientation(BaseProperty):
orientation_type: int = dataclasses.field(default=1973921119) # Choice
flags_orientation: int = dataclasses.field(default=8) # Flagset
look_at_type: enums.LookAtType = dataclasses.field(default=enums.LookAtType.Unknown1)
locator_name: str = dataclasses.field(default='')
pitch_angle: float = dataclasses.field(default=0.0)
target_path_determination: PathDetermination = dataclasses.field(default_factory=PathDetermination)
distance: float = dataclasses.field(default=0.0)
distance_direction_method: enums.DistanceDirectionMethod = dataclasses.field(default=enums.DistanceDirectionMethod.Unknown1)
look_at_motion: Convergence = dataclasses.field(default_factory=Convergence)
look_at_offset: OffsetSplines = dataclasses.field(default_factory=OffsetSplines)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
spindle_orientation: SpindleOrientation = dataclasses.field(default_factory=SpindleOrientation)
surface_orientation: SurfaceOrientation = dataclasses.field(default_factory=SurfaceOrientation)
unknown_struct74: UnknownStruct23 = dataclasses.field(default_factory=UnknownStruct23)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x0e') # 14 properties
data.write(b'\\r\xa9d') # 0x5c72a964
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.orientation_type))
data.write(b'b\x19\x02.') # 0x6219022e
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_orientation))
data.write(b'D\x19\x1f\xb8') # 0x44191fb8
data.write(b'\x00\x04') # size
self.look_at_type.to_stream(data)
data.write(b'\xfb\xc6\xc1\x10') # 0xfbc6c110
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.locator_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'o\xf79.') # 0x6ff7392e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch_angle))
data.write(b'2F\x8c\x89') # 0x32468c89
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_path_determination.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3\xbfC\xbe') # 0xc3bf43be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance))
data.write(b'\x10\xe7\x12\x1b') # 0x10e7121b
data.write(b'\x00\x04') # size
self.distance_direction_method.to_stream(data)
data.write(b'\xdaT\xb3\xe9') # 0xda54b3e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\t\x1f)6') # 0x91f2936
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_at_offset.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xdf\xbf\xa7') # 0xc4dfbfa7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86\xbc\x03\xd3') # 0x86bc03d3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"\xe1\xde\xee'") # 0xe1deee27
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surface_orientation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf6\xbbD\xea') # 0xf6bb44ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct74.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
orientation_type=data['orientation_type'],
flags_orientation=data['flags_orientation'],
look_at_type=enums.LookAtType.from_json(data['look_at_type']),
locator_name=data['locator_name'],
pitch_angle=data['pitch_angle'],
target_path_determination=PathDetermination.from_json(data['target_path_determination']),
distance=data['distance'],
distance_direction_method=enums.DistanceDirectionMethod.from_json(data['distance_direction_method']),
look_at_motion=Convergence.from_json(data['look_at_motion']),
look_at_offset=OffsetSplines.from_json(data['look_at_offset']),
target_control_spline=Spline.from_json(data['target_control_spline']),
spindle_orientation=SpindleOrientation.from_json(data['spindle_orientation']),
surface_orientation=SurfaceOrientation.from_json(data['surface_orientation']),
unknown_struct74=UnknownStruct23.from_json(data['unknown_struct74']),
)
def to_json(self) -> dict:
return {
'orientation_type': self.orientation_type,
'flags_orientation': self.flags_orientation,
'look_at_type': self.look_at_type.to_json(),
'locator_name': self.locator_name,
'pitch_angle': self.pitch_angle,
'target_path_determination': self.target_path_determination.to_json(),
'distance': self.distance,
'distance_direction_method': self.distance_direction_method.to_json(),
'look_at_motion': self.look_at_motion.to_json(),
'look_at_offset': self.look_at_offset.to_json(),
'target_control_spline': self.target_control_spline.to_json(),
'spindle_orientation': self.spindle_orientation.to_json(),
'surface_orientation': self.surface_orientation.to_json(),
'unknown_struct74': self.unknown_struct74.to_json(),
}
def _decode_orientation_type(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_flags_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_look_at_type(data: typing.BinaryIO, property_size: int):
return enums.LookAtType.from_stream(data)
def _decode_locator_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_pitch_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_path_determination(data: typing.BinaryIO, property_size: int):
return PathDetermination.from_stream(data, property_size)
def _decode_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance_direction_method(data: typing.BinaryIO, property_size: int):
return enums.DistanceDirectionMethod.from_stream(data)
def _decode_look_at_motion(data: typing.BinaryIO, property_size: int):
return Convergence.from_stream(data, property_size)
def _decode_look_at_offset(data: typing.BinaryIO, property_size: int):
return OffsetSplines.from_stream(data, property_size)
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_spindle_orientation(data: typing.BinaryIO, property_size: int):
return SpindleOrientation.from_stream(data, property_size)
def _decode_surface_orientation(data: typing.BinaryIO, property_size: int):
return SurfaceOrientation.from_stream(data, property_size)
def _decode_unknown_struct74(data: typing.BinaryIO, property_size: int):
return UnknownStruct23.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x5c72a964: ('orientation_type', _decode_orientation_type),
0x6219022e: ('flags_orientation', _decode_flags_orientation),
0x44191fb8: ('look_at_type', _decode_look_at_type),
0xfbc6c110: ('locator_name', _decode_locator_name),
0x6ff7392e: ('pitch_angle', _decode_pitch_angle),
0x32468c89: ('target_path_determination', _decode_target_path_determination),
0xc3bf43be: ('distance', _decode_distance),
0x10e7121b: ('distance_direction_method', _decode_distance_direction_method),
0xda54b3e9: ('look_at_motion', _decode_look_at_motion),
0x91f2936: ('look_at_offset', _decode_look_at_offset),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0x86bc03d3: ('spindle_orientation', _decode_spindle_orientation),
0xe1deee27: ('surface_orientation', _decode_surface_orientation),
0xf6bb44ea: ('unknown_struct74', _decode_unknown_struct74),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/CameraOrientation.py | 0.554591 | 0.29489 | CameraOrientation.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.corruption.archetypes.RevolutionControl import RevolutionControl
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class CameraControls(BaseProperty):
look_up: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
look_down: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
look_left: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
look_right: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
unknown: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
view_lock: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
skip_cinematic: RevolutionControl = dataclasses.field(default_factory=RevolutionControl)
look_up_control: Spline = dataclasses.field(default_factory=Spline)
look_down_control: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\t') # 9 properties
data.write(b'\x1c\x1doI') # 0x1c1d6f49
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_up.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1a \xd5\xf4') # 0x1a20d5f4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_down.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x90A^y') # 0x90415e79
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_left.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#\xc13<') # 0x23c1333c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_right.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+K\xa1\xa3') # 0x2b4ba1a3
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'\xd4\x7f$\xd7') # 0xd47f24d7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.view_lock.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\xa3\xe0}') # 0x19a3e07d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.skip_cinematic.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa03\x90\xa5') # 0xa03390a5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_up_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7F\xf7~') # 0xe746f77e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.look_down_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
@classmethod
def from_json(cls, data: dict):
return cls(
look_up=RevolutionControl.from_json(data['look_up']),
look_down=RevolutionControl.from_json(data['look_down']),
look_left=RevolutionControl.from_json(data['look_left']),
look_right=RevolutionControl.from_json(data['look_right']),
unknown=RevolutionControl.from_json(data['unknown']),
view_lock=RevolutionControl.from_json(data['view_lock']),
skip_cinematic=RevolutionControl.from_json(data['skip_cinematic']),
look_up_control=Spline.from_json(data['look_up_control']),
look_down_control=Spline.from_json(data['look_down_control']),
)
def to_json(self) -> dict:
return {
'look_up': self.look_up.to_json(),
'look_down': self.look_down.to_json(),
'look_left': self.look_left.to_json(),
'look_right': self.look_right.to_json(),
'unknown': self.unknown.to_json(),
'view_lock': self.view_lock.to_json(),
'skip_cinematic': self.skip_cinematic.to_json(),
'look_up_control': self.look_up_control.to_json(),
'look_down_control': self.look_down_control.to_json(),
}
def _decode_look_up(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_look_down(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_look_left(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_look_right(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_view_lock(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_skip_cinematic(data: typing.BinaryIO, property_size: int):
return RevolutionControl.from_stream(data, property_size)
def _decode_look_up_control(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_look_down_control(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x1c1d6f49: ('look_up', _decode_look_up),
0x1a20d5f4: ('look_down', _decode_look_down),
0x90415e79: ('look_left', _decode_look_left),
0x23c1333c: ('look_right', _decode_look_right),
0x2b4ba1a3: ('unknown', _decode_unknown),
0xd47f24d7: ('view_lock', _decode_view_lock),
0x19a3e07d: ('skip_cinematic', _decode_skip_cinematic),
0xa03390a5: ('look_up_control', _decode_look_up_control),
0xe746f77e: ('look_down_control', _decode_look_down_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/CameraControls.py | 0.553264 | 0.281554 | CameraControls.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.corruption as enums
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ShipDecalControllerStruct(BaseProperty):
save_game: enums.SaveGame = dataclasses.field(default=enums.SaveGame.Unknown1)
texture_asset: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack(">H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x00\x02') # 2 properties
data.write(b'w\xed\xd0\xf1') # 0x77edd0f1
data.write(b'\x00\x04') # size
self.save_game.to_stream(data)
data.write(b'/\x11\xc1O') # 0x2f11c14f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture_asset))
@classmethod
def from_json(cls, data: dict):
return cls(
save_game=enums.SaveGame.from_json(data['save_game']),
texture_asset=data['texture_asset'],
)
def to_json(self) -> dict:
return {
'save_game': self.save_game.to_json(),
'texture_asset': self.texture_asset,
}
_FAST_FORMAT = None
_FAST_IDS = (0x77edd0f1, 0x2f11c14f)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ShipDecalControllerStruct]:
if property_count != 2:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('>LHLLHQ')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(24))
if (dec[0], dec[3]) != _FAST_IDS:
data.seek(before)
return None
return ShipDecalControllerStruct(
enums.SaveGame(dec[2]),
dec[5],
)
def _decode_save_game(data: typing.BinaryIO, property_size: int):
return enums.SaveGame.from_stream(data)
def _decode_texture_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]]] = {
0x77edd0f1: ('save_game', _decode_save_game),
0x2f11c14f: ('texture_asset', _decode_texture_asset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/archetypes/ShipDecalControllerStruct.py | 0.611846 | 0.241926 | ShipDecalControllerStruct.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.