code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ContextActionImageFocus(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
initial_angle: float = dataclasses.field(default=0.0)
min_angle: float = dataclasses.field(default=-90.0)
max_angle: float = dataclasses.field(default=90.0)
fudge_angle: float = dataclasses.field(default=2.0)
lock_angle: float = dataclasses.field(default=0.0)
lock_time: float = dataclasses.field(default=1.0)
drift_angle: float = dataclasses.field(default=2.0)
drift_period: float = dataclasses.field(default=4.0)
rotation_scale: float = dataclasses.field(default=1.0)
movement_distance: float = dataclasses.field(default=0.07500000298023224)
rotation_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
animation: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'CAIF'
@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'\x90\xac\x80A') # 0x90ac8041
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_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))
data.write(b'9\xbd\x0fp') # 0x39bd0f70
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fudge_angle))
data.write(b'd\xed\xce\xf1') # 0x64edcef1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lock_angle))
data.write(b'0\x8e\xdcD') # 0x308edc44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.lock_time))
data.write(b'G\x07#;') # 0x4707233b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drift_angle))
data.write(b'S\x9d0\x90') # 0x539d3090
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.drift_period))
data.write(b'^\x0e\xe1W') # 0x5e0ee157
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotation_scale))
data.write(b'\x1a\x8aE\xfe') # 0x1a8a45fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.movement_distance))
data.write(b'\xd7\x02\xeb\xd7') # 0xd702ebd7
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.rotation_sound))
data.write(b'\xaa\xcd\xb1\x1c') # 0xaacdb11c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
initial_angle=data['initial_angle'],
min_angle=data['min_angle'],
max_angle=data['max_angle'],
fudge_angle=data['fudge_angle'],
lock_angle=data['lock_angle'],
lock_time=data['lock_time'],
drift_angle=data['drift_angle'],
drift_period=data['drift_period'],
rotation_scale=data['rotation_scale'],
movement_distance=data['movement_distance'],
rotation_sound=data['rotation_sound'],
animation=data['animation'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'initial_angle': self.initial_angle,
'min_angle': self.min_angle,
'max_angle': self.max_angle,
'fudge_angle': self.fudge_angle,
'lock_angle': self.lock_angle,
'lock_time': self.lock_time,
'drift_angle': self.drift_angle,
'drift_period': self.drift_period,
'rotation_scale': self.rotation_scale,
'movement_distance': self.movement_distance,
'rotation_sound': self.rotation_sound,
'animation': self.animation,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_initial_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]
def _decode_fudge_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lock_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_lock_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drift_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_drift_period(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_movement_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(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),
0x90ac8041: ('initial_angle', _decode_initial_angle),
0x992c2df5: ('min_angle', _decode_min_angle),
0xd9635583: ('max_angle', _decode_max_angle),
0x39bd0f70: ('fudge_angle', _decode_fudge_angle),
0x64edcef1: ('lock_angle', _decode_lock_angle),
0x308edc44: ('lock_time', _decode_lock_time),
0x4707233b: ('drift_angle', _decode_drift_angle),
0x539d3090: ('drift_period', _decode_drift_period),
0x5e0ee157: ('rotation_scale', _decode_rotation_scale),
0x1a8a45fe: ('movement_distance', _decode_movement_distance),
0xd702ebd7: ('rotation_sound', _decode_rotation_sound),
0xaacdb11c: ('animation', _decode_animation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ContextActionImageFocus.py | 0.638046 | 0.338596 | ContextActionImageFocus.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class FishCloudModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: bool = dataclasses.field(default=False)
rotate: bool = dataclasses.field(default=False)
influence_distance: float = dataclasses.field(default=8.0)
influence_priority: float = dataclasses.field(default=0.4000000059604645)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'FSHM'
@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'\xea-L\xa8') # 0xea2d4ca8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x921\t\xd6') # 0x923109d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.rotate))
data.write(b'xd\xad\x0e') # 0x7864ad0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.influence_distance))
data.write(b'\xab\xa2\xd9\xed') # 0xaba2d9ed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.influence_priority))
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'],
rotate=data['rotate'],
influence_distance=data['influence_distance'],
influence_priority=data['influence_priority'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown,
'rotate': self.rotate,
'influence_distance': self.influence_distance,
'influence_priority': self.influence_priority,
}
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_rotate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_influence_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_influence_priority(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),
0xea2d4ca8: ('unknown', _decode_unknown),
0x923109d6: ('rotate', _decode_rotate),
0x7864ad0e: ('influence_distance', _decode_influence_distance),
0xaba2d9ed: ('influence_priority', _decode_influence_priority),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FishCloudModifier.py | 0.665628 | 0.351283 | FishCloudModifier.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanIncoming(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
scan_asset: AssetId = dataclasses.field(metadata={'asset_types': ['SCAN']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SCIC'
@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'`{\xc7\x9e') # 0x607bc79e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.scan_asset))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
scan_asset=data['scan_asset'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'scan_asset': self.scan_asset,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_scan_asset(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x607bc79e: ('scan_asset', _decode_scan_asset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ScanIncoming.py | 0.607896 | 0.325882 | ScanIncoming.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.TextProperties import TextProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Subtitles(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
text_position_x: int = dataclasses.field(default=0)
text_position_y: int = dataclasses.field(default=100)
japan_text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
japan_text_position_x: int = dataclasses.field(default=0)
japan_text_position_y: int = dataclasses.field(default=100)
string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
initial_string_index: int = dataclasses.field(default=0)
fade_in_time: float = dataclasses.field(default=0.0)
fade_out_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SUBT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0T>f') # 0xe0543e66
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.text_properties.to_stream(data, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3:\x87\xc7') # 0xc33a87c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_x))
data.write(b'{\x86\xe0\xa2') # 0x7b86e0a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_y))
data.write(b'\xc8\xe4A\xfa') # 0xc8e441fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.japan_text_properties.to_stream(data, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S\xa7\xf7\xa7') # 0x53a7f7a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_x))
data.write(b'\xeb\x1b\x90\xc2') # 0xeb1b90c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_y))
data.write(b'\xfd\x95\xed*') # 0xfd95ed2a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.string_table))
data.write(b'l\xe4f\x89') # 0x6ce46689
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_string_index))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
text_properties=TextProperties.from_json(data['text_properties']),
text_position_x=data['text_position_x'],
text_position_y=data['text_position_y'],
japan_text_properties=TextProperties.from_json(data['japan_text_properties']),
japan_text_position_x=data['japan_text_position_x'],
japan_text_position_y=data['japan_text_position_y'],
string_table=data['string_table'],
initial_string_index=data['initial_string_index'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'text_properties': self.text_properties.to_json(),
'text_position_x': self.text_position_x,
'text_position_y': self.text_position_y,
'japan_text_properties': self.japan_text_properties.to_json(),
'japan_text_position_x': self.japan_text_position_x,
'japan_text_position_y': self.japan_text_position_y,
'string_table': self.string_table,
'initial_string_index': self.initial_string_index,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
def _decode_text_position_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
def _decode_japan_text_position_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_initial_string_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe0543e66: ('text_properties', _decode_text_properties),
0xc33a87c7: ('text_position_x', _decode_text_position_x),
0x7b86e0a2: ('text_position_y', _decode_text_position_y),
0xc8e441fa: ('japan_text_properties', _decode_japan_text_properties),
0x53a7f7a7: ('japan_text_position_x', _decode_japan_text_position_x),
0xeb1b90c2: ('japan_text_position_y', _decode_japan_text_position_y),
0xfd95ed2a: ('string_table', _decode_string_table),
0x6ce46689: ('initial_string_index', _decode_initial_string_index),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Subtitles.py | 0.553023 | 0.250019 | Subtitles.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RSPL(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
splash_scale: float = dataclasses.field(default=1.0)
max_splashes: int = dataclasses.field(default=20)
generation_rate: int = dataclasses.field(default=2)
start_height: float = dataclasses.field(default=1.0)
alpha_factor: float = dataclasses.field(default=0.125)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'RSPL'
@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'\x08#\x1a\xc9') # 0x8231ac9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.splash_scale))
data.write(b'bH\xaa\x06') # 0x6248aa06
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_splashes))
data.write(b'\x7fZ\x86\xdd') # 0x7f5a86dd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.generation_rate))
data.write(b"\xc4\x05'\xf6") # 0xc40527f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_height))
data.write(b'\xe0N\x02p') # 0xe04e0270
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alpha_factor))
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']),
splash_scale=data['splash_scale'],
max_splashes=data['max_splashes'],
generation_rate=data['generation_rate'],
start_height=data['start_height'],
alpha_factor=data['alpha_factor'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'splash_scale': self.splash_scale,
'max_splashes': self.max_splashes,
'generation_rate': self.generation_rate,
'start_height': self.start_height,
'alpha_factor': self.alpha_factor,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_splash_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_generation_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_start_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alpha_factor(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),
0x8231ac9: ('splash_scale', _decode_splash_scale),
0x6248aa06: ('max_splashes', _decode_max_splashes),
0x7f5a86dd: ('generation_rate', _decode_generation_rate),
0xc40527f6: ('start_height', _decode_start_height),
0xe04e0270: ('alpha_factor', _decode_alpha_factor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/RSPL.py | 0.614278 | 0.314406 | RSPL.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.AiDifficultySettings import AiDifficultySettings
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct42 import UnknownStruct42
@dataclasses.dataclass()
class GhorUpperBody(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
ai_difficulty_settings: AiDifficultySettings = dataclasses.field(default_factory=AiDifficultySettings)
unknown_struct42: UnknownStruct42 = dataclasses.field(default_factory=UnknownStruct42)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'GHRU'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Ghor.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Bi\x14\x90') # 0x42691490
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ai_difficulty_settings.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\x13^\x9b') # 0xfc135e9b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct42.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']),
ai_difficulty_settings=AiDifficultySettings.from_json(data['ai_difficulty_settings']),
unknown_struct42=UnknownStruct42.from_json(data['unknown_struct42']),
)
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(),
'ai_difficulty_settings': self.ai_difficulty_settings.to_json(),
'unknown_struct42': self.unknown_struct42.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_ai_difficulty_settings(data: typing.BinaryIO, property_size: int):
return AiDifficultySettings.from_stream(data, property_size)
def _decode_unknown_struct42(data: typing.BinaryIO, property_size: int):
return UnknownStruct42.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),
0x42691490: ('ai_difficulty_settings', _decode_ai_difficulty_settings),
0xfc135e9b: ('unknown_struct42', _decode_unknown_struct42),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GhorUpperBody.py | 0.626924 | 0.35248 | GhorUpperBody.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.AuroraUnit1Data import AuroraUnit1Data
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class AuroraUnit1(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
aurora_unit1_data_0x93aedac3: AuroraUnit1Data = dataclasses.field(default_factory=AuroraUnit1Data)
aurora_unit1_data_0x867ab15e: AuroraUnit1Data = dataclasses.field(default_factory=AuroraUnit1Data)
aurora_unit1_data_0xb3c5f11b: AuroraUnit1Data = dataclasses.field(default_factory=AuroraUnit1Data)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'AUR1'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_AuroraUnit1.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\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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\xae\xda\xc3') # 0x93aedac3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.aurora_unit1_data_0x93aedac3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86z\xb1^') # 0x867ab15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.aurora_unit1_data_0x867ab15e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\xc5\xf1\x1b') # 0xb3c5f11b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.aurora_unit1_data_0xb3c5f11b.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']),
actor_information=ActorParameters.from_json(data['actor_information']),
aurora_unit1_data_0x93aedac3=AuroraUnit1Data.from_json(data['aurora_unit1_data_0x93aedac3']),
aurora_unit1_data_0x867ab15e=AuroraUnit1Data.from_json(data['aurora_unit1_data_0x867ab15e']),
aurora_unit1_data_0xb3c5f11b=AuroraUnit1Data.from_json(data['aurora_unit1_data_0xb3c5f11b']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'aurora_unit1_data_0x93aedac3': self.aurora_unit1_data_0x93aedac3.to_json(),
'aurora_unit1_data_0x867ab15e': self.aurora_unit1_data_0x867ab15e.to_json(),
'aurora_unit1_data_0xb3c5f11b': self.aurora_unit1_data_0xb3c5f11b.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={'turn_speed': 360.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_aurora_unit1_data_0x93aedac3(data: typing.BinaryIO, property_size: int):
return AuroraUnit1Data.from_stream(data, property_size)
def _decode_aurora_unit1_data_0x867ab15e(data: typing.BinaryIO, property_size: int):
return AuroraUnit1Data.from_stream(data, property_size)
def _decode_aurora_unit1_data_0xb3c5f11b(data: typing.BinaryIO, property_size: int):
return AuroraUnit1Data.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0x93aedac3: ('aurora_unit1_data_0x93aedac3', _decode_aurora_unit1_data_0x93aedac3),
0x867ab15e: ('aurora_unit1_data_0x867ab15e', _decode_aurora_unit1_data_0x867ab15e),
0xb3c5f11b: ('aurora_unit1_data_0xb3c5f11b', _decode_aurora_unit1_data_0xb3c5f11b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AuroraUnit1.py | 0.560854 | 0.377225 | AuroraUnit1.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.corruption.archetypes.TriggerInfo import TriggerInfo
from retro_data_structures.properties.corruption.archetypes.VisorParameters import VisorParameters
@dataclasses.dataclass()
class DamageableTriggerOrientated(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
orbitable: bool = dataclasses.field(default=False)
enable_seeker_lock_on: bool = dataclasses.field(default=False)
invulnerable: bool = dataclasses.field(default=False)
show_on_radar: bool = dataclasses.field(default=False)
visor: VisorParameters = dataclasses.field(default_factory=VisorParameters)
damage_originator: enums.DamageableTriggerEnum = dataclasses.field(default=enums.DamageableTriggerEnum.Unknown1)
trigger_properties: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
is_hostile: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DTRO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\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'pKSi') # 0x704b5369
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orbitable))
data.write(b']\xfdx ') # 0x5dfd7820
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_seeker_lock_on))
data.write(b'fR\xbd\xd7') # 0x6652bdd7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.invulnerable))
data.write(b'\xf0\xe0zK') # 0xf0e07a4b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.show_on_radar))
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'\x8b\x9d!#') # 0x8b9d2123
data.write(b'\x00\x04') # size
self.damage_originator.to_stream(data)
data.write(b'\xbb\xfe\xe9>') # 0xbbfee93e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'p\x1ba\xb3') # 0x701b61b3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_hostile))
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']),
orbitable=data['orbitable'],
enable_seeker_lock_on=data['enable_seeker_lock_on'],
invulnerable=data['invulnerable'],
show_on_radar=data['show_on_radar'],
visor=VisorParameters.from_json(data['visor']),
damage_originator=enums.DamageableTriggerEnum.from_json(data['damage_originator']),
trigger_properties=TriggerInfo.from_json(data['trigger_properties']),
is_hostile=data['is_hostile'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'orbitable': self.orbitable,
'enable_seeker_lock_on': self.enable_seeker_lock_on,
'invulnerable': self.invulnerable,
'show_on_radar': self.show_on_radar,
'visor': self.visor.to_json(),
'damage_originator': self.damage_originator.to_json(),
'trigger_properties': self.trigger_properties.to_json(),
'is_hostile': self.is_hostile,
}
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_orbitable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_enable_seeker_lock_on(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_invulnerable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_show_on_radar(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_visor(data: typing.BinaryIO, property_size: int):
return VisorParameters.from_stream(data, property_size)
def _decode_damage_originator(data: typing.BinaryIO, property_size: int):
return enums.DamageableTriggerEnum.from_stream(data)
def _decode_trigger_properties(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x704b5369: ('orbitable', _decode_orbitable),
0x5dfd7820: ('enable_seeker_lock_on', _decode_enable_seeker_lock_on),
0x6652bdd7: ('invulnerable', _decode_invulnerable),
0xf0e07a4b: ('show_on_radar', _decode_show_on_radar),
0x5ad250e: ('visor', _decode_visor),
0x8b9d2123: ('damage_originator', _decode_damage_originator),
0xbbfee93e: ('trigger_properties', _decode_trigger_properties),
0x701b61b3: ('is_hostile', _decode_is_hostile),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DamageableTriggerOrientated.py | 0.543833 | 0.332635 | DamageableTriggerOrientated.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class WorldAttributes(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0x932e690f: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unknown_0x133b973d: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WLDA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x93.i\x0f') # 0x932e690f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x932e690f))
data.write(b'\x13;\x97=') # 0x133b973d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.unknown_0x133b973d))
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_0x932e690f=data['unknown_0x932e690f'],
unknown_0x133b973d=data['unknown_0x133b973d'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0x932e690f': self.unknown_0x932e690f,
'unknown_0x133b973d': self.unknown_0x133b973d,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0x932e690f(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x133b973d(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),
0x932e690f: ('unknown_0x932e690f', _decode_unknown_0x932e690f),
0x133b973d: ('unknown_0x133b973d', _decode_unknown_0x133b973d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WorldAttributes.py | 0.587707 | 0.298875 | WorldAttributes.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.CableProperties import CableProperties
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Cable(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
cable_properties: CableProperties = dataclasses.field(default_factory=CableProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CABL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptCable.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93\xb9=\xb9') # 0x93b93db9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cable_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
cable_properties=CableProperties.from_json(data['cable_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'cable_properties': self.cable_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_cable_properties(data: typing.BinaryIO, property_size: int):
return CableProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x93b93db9: ('cable_properties', _decode_cable_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Cable.py | 0.685634 | 0.306871 | Cable.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.Ridley1Data import Ridley1Data
from retro_data_structures.properties.corruption.archetypes.UnknownStruct53 import UnknownStruct53
@dataclasses.dataclass()
class Ridley1(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct53: UnknownStruct53 = dataclasses.field(default_factory=UnknownStruct53)
ridley1_data_0x3a80d135: Ridley1Data = dataclasses.field(default_factory=Ridley1Data)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
ridley1_data_0x1c1698f5: Ridley1Data = dataclasses.field(default_factory=Ridley1Data)
patterned_ai_0x1464ae05: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
ridley1_data_0x1cf90c26: Ridley1Data = dataclasses.field(default_factory=Ridley1Data)
patterned_ai_0x24d00673: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'RID1'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Ridley1.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\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'_\xd3\xdeN') # 0x5fd3de4e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct53.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b':\x80\xd15') # 0x3a80d135
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ridley1_data_0x3a80d135.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\x16\x98\xf5') # 0x1c1698f5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ridley1_data_0x1c1698f5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14d\xae\x05') # 0x1464ae05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x1464ae05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\xf9\x0c&') # 0x1cf90c26
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ridley1_data_0x1cf90c26.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xd0\x06s') # 0x24d00673
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x24d00673.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)
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_struct53=UnknownStruct53.from_json(data['unknown_struct53']),
ridley1_data_0x3a80d135=Ridley1Data.from_json(data['ridley1_data_0x3a80d135']),
patterned=PatternedAITypedef.from_json(data['patterned']),
ridley1_data_0x1c1698f5=Ridley1Data.from_json(data['ridley1_data_0x1c1698f5']),
patterned_ai_0x1464ae05=PatternedAITypedef.from_json(data['patterned_ai_0x1464ae05']),
ridley1_data_0x1cf90c26=Ridley1Data.from_json(data['ridley1_data_0x1cf90c26']),
patterned_ai_0x24d00673=PatternedAITypedef.from_json(data['patterned_ai_0x24d00673']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct53': self.unknown_struct53.to_json(),
'ridley1_data_0x3a80d135': self.ridley1_data_0x3a80d135.to_json(),
'patterned': self.patterned.to_json(),
'ridley1_data_0x1c1698f5': self.ridley1_data_0x1c1698f5.to_json(),
'patterned_ai_0x1464ae05': self.patterned_ai_0x1464ae05.to_json(),
'ridley1_data_0x1cf90c26': self.ridley1_data_0x1cf90c26.to_json(),
'patterned_ai_0x24d00673': self.patterned_ai_0x24d00673.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct53(data: typing.BinaryIO, property_size: int):
return UnknownStruct53.from_stream(data, property_size)
def _decode_ridley1_data_0x3a80d135(data: typing.BinaryIO, property_size: int):
return Ridley1Data.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_ridley1_data_0x1c1698f5(data: typing.BinaryIO, property_size: int):
return Ridley1Data.from_stream(data, property_size)
def _decode_patterned_ai_0x1464ae05(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_ridley1_data_0x1cf90c26(data: typing.BinaryIO, property_size: int):
return Ridley1Data.from_stream(data, property_size)
def _decode_patterned_ai_0x24d00673(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x5fd3de4e: ('unknown_struct53', _decode_unknown_struct53),
0x3a80d135: ('ridley1_data_0x3a80d135', _decode_ridley1_data_0x3a80d135),
0xb3774750: ('patterned', _decode_patterned),
0x1c1698f5: ('ridley1_data_0x1c1698f5', _decode_ridley1_data_0x1c1698f5),
0x1464ae05: ('patterned_ai_0x1464ae05', _decode_patterned_ai_0x1464ae05),
0x1cf90c26: ('ridley1_data_0x1cf90c26', _decode_ridley1_data_0x1cf90c26),
0x24d00673: ('patterned_ai_0x24d00673', _decode_patterned_ai_0x24d00673),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Ridley1.py | 0.500244 | 0.348604 | Ridley1.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.SwarmBasicsData import SwarmBasicsData
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 WallCrawlerSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
swarm_basics_data: SwarmBasicsData = dataclasses.field(default_factory=SwarmBasicsData)
wall_crawler_death_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SWRM'
@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
num_properties_written = 5
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'\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)
if self.active != default_override.get('active', True):
num_properties_written += 1
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'L\xfcF\xfe') # 0x4cfc46fe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swarm_basics_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'h2Io') # 0x6832496f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.wall_crawler_death_effect))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.write(struct.pack(">H", num_properties_written))
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']),
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
active=data['active'],
swarm_basics_data=SwarmBasicsData.from_json(data['swarm_basics_data']),
wall_crawler_death_effect=data['wall_crawler_death_effect'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'character_animation_information': self.character_animation_information.to_json(),
'active': self.active,
'swarm_basics_data': self.swarm_basics_data.to_json(),
'wall_crawler_death_effect': self.wall_crawler_death_effect,
}
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_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_swarm_basics_data(data: typing.BinaryIO, property_size: int):
return SwarmBasicsData.from_stream(data, property_size)
def _decode_wall_crawler_death_effect(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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xc6bb2f45: ('active', _decode_active),
0x4cfc46fe: ('swarm_basics_data', _decode_swarm_basics_data),
0x6832496f: ('wall_crawler_death_effect', _decode_wall_crawler_death_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WallCrawlerSwarm.py | 0.627267 | 0.285689 | WallCrawlerSwarm.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ElectroMagneticPulse(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
initial_size: float = dataclasses.field(default=0.10000000149011612)
final_size: float = dataclasses.field(default=34.0)
duration: float = dataclasses.field(default=1.3329999446868896)
unknown_0x96bd6426: float = dataclasses.field(default=1.0)
unknown_0xd7aa5ba0: float = dataclasses.field(default=3.0)
backward_forward_sweep_chance: float = dataclasses.field(default=0.4000000059604645)
unknown_0xce54e50e: float = dataclasses.field(default=0.800000011920929)
explosion: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'EMPU'
@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, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'cm\xf2\xdb') # 0x636df2db
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.initial_size))
data.write(b'\x1ef\x86\xfe') # 0x1e6686fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.final_size))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\x96\xbdd&') # 0x96bd6426
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x96bd6426))
data.write(b'\xd7\xaa[\xa0') # 0xd7aa5ba0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd7aa5ba0))
data.write(b'\x15\xeb\xb6\xe9') # 0x15ebb6e9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.backward_forward_sweep_chance))
data.write(b'\xceT\xe5\x0e') # 0xce54e50e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xce54e50e))
data.write(b'\xd8\xc6\xd1\\') # 0xd8c6d15c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.explosion))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
initial_size=data['initial_size'],
final_size=data['final_size'],
duration=data['duration'],
unknown_0x96bd6426=data['unknown_0x96bd6426'],
unknown_0xd7aa5ba0=data['unknown_0xd7aa5ba0'],
backward_forward_sweep_chance=data['backward_forward_sweep_chance'],
unknown_0xce54e50e=data['unknown_0xce54e50e'],
explosion=data['explosion'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'initial_size': self.initial_size,
'final_size': self.final_size,
'duration': self.duration,
'unknown_0x96bd6426': self.unknown_0x96bd6426,
'unknown_0xd7aa5ba0': self.unknown_0xd7aa5ba0,
'backward_forward_sweep_chance': self.backward_forward_sweep_chance,
'unknown_0xce54e50e': self.unknown_0xce54e50e,
'explosion': self.explosion,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_initial_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_final_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x96bd6426(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd7aa5ba0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_backward_forward_sweep_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xce54e50e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_explosion(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),
0x636df2db: ('initial_size', _decode_initial_size),
0x1e6686fe: ('final_size', _decode_final_size),
0x8b51e23f: ('duration', _decode_duration),
0x96bd6426: ('unknown_0x96bd6426', _decode_unknown_0x96bd6426),
0xd7aa5ba0: ('unknown_0xd7aa5ba0', _decode_unknown_0xd7aa5ba0),
0x15ebb6e9: ('backward_forward_sweep_chance', _decode_backward_forward_sweep_chance),
0xce54e50e: ('unknown_0xce54e50e', _decode_unknown_0xce54e50e),
0xd8c6d15c: ('explosion', _decode_explosion),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ElectroMagneticPulse.py | 0.618089 | 0.289428 | ElectroMagneticPulse.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.TriggerInfo import TriggerInfo
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Steam(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
steam: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
strength: float = dataclasses.field(default=0.3499999940395355)
fade_in_rate: float = dataclasses.field(default=1.0)
fade_out_rate: float = dataclasses.field(default=2.0)
radius: float = dataclasses.field(default=0.0)
unknown_0xa366c949: bool = dataclasses.field(default=False)
unknown_0x606539fa: bool = dataclasses.field(default=False)
filter_shape: enums.FilterShape = dataclasses.field(default=enums.FilterShape.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'STEM'
@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'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'&4`P') # 0x26346050
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.steam))
data.write(b'O\x8f_\\') # 0x4f8f5f5c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.strength))
data.write(b'\xc2\x13\x8f=') # 0xc2138f3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_rate))
data.write(b'.\x9f%\x9e') # 0x2e9f259e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_rate))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\xa3f\xc9I') # 0xa366c949
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa366c949))
data.write(b'`e9\xfa') # 0x606539fa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x606539fa))
data.write(b'\x92\x86\x90R') # 0x92869052
data.write(b'\x00\x04') # size
self.filter_shape.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']),
trigger=TriggerInfo.from_json(data['trigger']),
steam=data['steam'],
strength=data['strength'],
fade_in_rate=data['fade_in_rate'],
fade_out_rate=data['fade_out_rate'],
radius=data['radius'],
unknown_0xa366c949=data['unknown_0xa366c949'],
unknown_0x606539fa=data['unknown_0x606539fa'],
filter_shape=enums.FilterShape.from_json(data['filter_shape']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger': self.trigger.to_json(),
'steam': self.steam,
'strength': self.strength,
'fade_in_rate': self.fade_in_rate,
'fade_out_rate': self.fade_out_rate,
'radius': self.radius,
'unknown_0xa366c949': self.unknown_0xa366c949,
'unknown_0x606539fa': self.unknown_0x606539fa,
'filter_shape': self.filter_shape.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_steam(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_strength(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa366c949(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x606539fa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_filter_shape(data: typing.BinaryIO, property_size: int):
return enums.FilterShape.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x77a27411: ('trigger', _decode_trigger),
0x26346050: ('steam', _decode_steam),
0x4f8f5f5c: ('strength', _decode_strength),
0xc2138f3d: ('fade_in_rate', _decode_fade_in_rate),
0x2e9f259e: ('fade_out_rate', _decode_fade_out_rate),
0x78c507eb: ('radius', _decode_radius),
0xa366c949: ('unknown_0xa366c949', _decode_unknown_0xa366c949),
0x606539fa: ('unknown_0x606539fa', _decode_unknown_0x606539fa),
0x92869052: ('filter_shape', _decode_filter_shape),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Steam.py | 0.546738 | 0.29105 | Steam.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.RotationSplines import RotationSplines
from retro_data_structures.properties.corruption.archetypes.ScaleSplines import ScaleSplines
from retro_data_structures.properties.corruption.archetypes.TranslationSplines import TranslationSplines
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class ActorTransform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_actor_transform: int = dataclasses.field(default=20) # Flagset
duration: float = dataclasses.field(default=10.0)
rotation_controls: RotationSplines = dataclasses.field(default_factory=RotationSplines)
scale_controls: ScaleSplines = dataclasses.field(default_factory=ScaleSplines)
translation_control: TranslationSplines = dataclasses.field(default_factory=TranslationSplines)
path_position: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ATRN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xc6\xcev\x89') # 0xc6ce7689
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_actor_transform))
data.write(b'\x8bQ\xe2?') # 0x8b51e23f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.duration))
data.write(b'\xef\xe4\xeaW') # 0xefe4ea57
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotation_controls.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/~\xc0\xa2') # 0x2f7ec0a2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scale_controls.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'i"g\xea') # 0x692267ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.translation_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\xb8\xaa\xca') # 0x51b8aaca
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.path_position.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_actor_transform=data['flags_actor_transform'],
duration=data['duration'],
rotation_controls=RotationSplines.from_json(data['rotation_controls']),
scale_controls=ScaleSplines.from_json(data['scale_controls']),
translation_control=TranslationSplines.from_json(data['translation_control']),
path_position=Spline.from_json(data['path_position']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_actor_transform': self.flags_actor_transform,
'duration': self.duration,
'rotation_controls': self.rotation_controls.to_json(),
'scale_controls': self.scale_controls.to_json(),
'translation_control': self.translation_control.to_json(),
'path_position': self.path_position.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_actor_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_controls(data: typing.BinaryIO, property_size: int):
return RotationSplines.from_stream(data, property_size)
def _decode_scale_controls(data: typing.BinaryIO, property_size: int):
return ScaleSplines.from_stream(data, property_size)
def _decode_translation_control(data: typing.BinaryIO, property_size: int):
return TranslationSplines.from_stream(data, property_size)
def _decode_path_position(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc6ce7689: ('flags_actor_transform', _decode_flags_actor_transform),
0x8b51e23f: ('duration', _decode_duration),
0xefe4ea57: ('rotation_controls', _decode_rotation_controls),
0x2f7ec0a2: ('scale_controls', _decode_scale_controls),
0x692267ea: ('translation_control', _decode_translation_control),
0x51b8aaca: ('path_position', _decode_path_position),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ActorTransform.py | 0.606032 | 0.398582 | ActorTransform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RadialDamage(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
radius: float = dataclasses.field(default=15.0)
auto_action: bool = dataclasses.field(default=False)
auto_delete: bool = dataclasses.field(default=False)
originator: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RADD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'8\x8e]\xd3') # 0x388e5dd3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_action))
data.write(b'\xdb\x82l\xbe') # 0xdb826cbe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_delete))
data.write(b'\x9c\x95\x1f\xed') # 0x9c951fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.originator))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage=DamageInfo.from_json(data['damage']),
radius=data['radius'],
auto_action=data['auto_action'],
auto_delete=data['auto_delete'],
originator=data['originator'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
'radius': self.radius,
'auto_action': self.auto_action,
'auto_delete': self.auto_delete,
'originator': self.originator,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_action(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_delete(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_originator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x337f9524: ('damage', _decode_damage),
0x78c507eb: ('radius', _decode_radius),
0x388e5dd3: ('auto_action', _decode_auto_action),
0xdb826cbe: ('auto_delete', _decode_auto_delete),
0x9c951fed: ('originator', _decode_originator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/RadialDamage.py | 0.588061 | 0.339239 | RadialDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.TriggerInfo import TriggerInfo
@dataclasses.dataclass()
class Trigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shape: int = dataclasses.field(default=1210786545) # Choice
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
fix_position_on_activate: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TRGR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\t\xec\xee\x0c') # 0x9ecee0c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.shape))
data.write(b'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\xa4>\xef') # 0x66a43eef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fix_position_on_activate))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shape=data['shape'],
trigger=TriggerInfo.from_json(data['trigger']),
fix_position_on_activate=data['fix_position_on_activate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shape': self.shape,
'trigger': self.trigger.to_json(),
'fix_position_on_activate': self.fix_position_on_activate,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shape(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_fix_position_on_activate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x9ecee0c: ('shape', _decode_shape),
0x77a27411: ('trigger', _decode_trigger),
0x66a43eef: ('fix_position_on_activate', _decode_fix_position_on_activate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Trigger.py | 0.606032 | 0.308451 | Trigger.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.CameraConstraints import CameraConstraints
from retro_data_structures.properties.corruption.archetypes.CameraFieldOfView import CameraFieldOfView
from retro_data_structures.properties.corruption.archetypes.CameraInterpolation import CameraInterpolation
from retro_data_structures.properties.corruption.archetypes.CameraMotion import CameraMotion
from retro_data_structures.properties.corruption.archetypes.CameraNavigation import CameraNavigation
from retro_data_structures.properties.corruption.archetypes.CameraOrientation import CameraOrientation
from retro_data_structures.properties.corruption.archetypes.CameraPosition import CameraPosition
from retro_data_structures.properties.corruption.archetypes.CameraRotation import CameraRotation
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.InterpolationMethod import InterpolationMethod
@dataclasses.dataclass()
class CameraHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
priority: int = dataclasses.field(default=50)
timer: float = dataclasses.field(default=0.0)
flags_camera_hint: int = dataclasses.field(default=30853) # Flagset
constraints: CameraConstraints = dataclasses.field(default_factory=CameraConstraints)
position_behavior: CameraPosition = dataclasses.field(default_factory=CameraPosition)
navigation_behavior: CameraNavigation = dataclasses.field(default_factory=CameraNavigation)
motion_behavior: CameraMotion = dataclasses.field(default_factory=CameraMotion)
orientation_behavior: CameraOrientation = dataclasses.field(default_factory=CameraOrientation)
rotation_behavior: CameraRotation = dataclasses.field(default_factory=CameraRotation)
field_of_view_behavior: CameraFieldOfView = dataclasses.field(default_factory=CameraFieldOfView)
interpolation_behavior: CameraInterpolation = dataclasses.field(default_factory=CameraInterpolation)
control_frame_interpolation: InterpolationMethod = dataclasses.field(default_factory=InterpolationMethod)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CAMH'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'B\x08vP') # 0x42087650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.priority))
data.write(b'\x87GU.') # 0x8747552e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.timer))
data.write(b'!\xd7 \xa9') # 0x21d720a9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_camera_hint))
data.write(b'\x97\xa9?\x8f') # 0x97a93f8f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.constraints.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd1\xbd\\@') # 0xd1bd5c40
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.position_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'K\xe3IK') # 0x4be3494b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.navigation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xeb\xc3\xe7u') # 0xebc3e775
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'e\xfc\x11\xff') # 0x65fc11ff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xa7\xc3\x8d') # 0xa7c38d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rotation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfc\x12j\xd1') # 0xfc126ad1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.field_of_view_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"vH'\xd4") # 0x764827d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.interpolation_behavior.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95\xd0\xd47') # 0x95d0d437
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.control_frame_interpolation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
priority=data['priority'],
timer=data['timer'],
flags_camera_hint=data['flags_camera_hint'],
constraints=CameraConstraints.from_json(data['constraints']),
position_behavior=CameraPosition.from_json(data['position_behavior']),
navigation_behavior=CameraNavigation.from_json(data['navigation_behavior']),
motion_behavior=CameraMotion.from_json(data['motion_behavior']),
orientation_behavior=CameraOrientation.from_json(data['orientation_behavior']),
rotation_behavior=CameraRotation.from_json(data['rotation_behavior']),
field_of_view_behavior=CameraFieldOfView.from_json(data['field_of_view_behavior']),
interpolation_behavior=CameraInterpolation.from_json(data['interpolation_behavior']),
control_frame_interpolation=InterpolationMethod.from_json(data['control_frame_interpolation']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'priority': self.priority,
'timer': self.timer,
'flags_camera_hint': self.flags_camera_hint,
'constraints': self.constraints.to_json(),
'position_behavior': self.position_behavior.to_json(),
'navigation_behavior': self.navigation_behavior.to_json(),
'motion_behavior': self.motion_behavior.to_json(),
'orientation_behavior': self.orientation_behavior.to_json(),
'rotation_behavior': self.rotation_behavior.to_json(),
'field_of_view_behavior': self.field_of_view_behavior.to_json(),
'interpolation_behavior': self.interpolation_behavior.to_json(),
'control_frame_interpolation': self.control_frame_interpolation.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flags_camera_hint(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_constraints(data: typing.BinaryIO, property_size: int):
return CameraConstraints.from_stream(data, property_size)
def _decode_position_behavior(data: typing.BinaryIO, property_size: int):
return CameraPosition.from_stream(data, property_size)
def _decode_navigation_behavior(data: typing.BinaryIO, property_size: int):
return CameraNavigation.from_stream(data, property_size)
def _decode_motion_behavior(data: typing.BinaryIO, property_size: int):
return CameraMotion.from_stream(data, property_size)
def _decode_orientation_behavior(data: typing.BinaryIO, property_size: int):
return CameraOrientation.from_stream(data, property_size)
def _decode_rotation_behavior(data: typing.BinaryIO, property_size: int):
return CameraRotation.from_stream(data, property_size)
def _decode_field_of_view_behavior(data: typing.BinaryIO, property_size: int):
return CameraFieldOfView.from_stream(data, property_size)
def _decode_interpolation_behavior(data: typing.BinaryIO, property_size: int):
return CameraInterpolation.from_stream(data, property_size)
def _decode_control_frame_interpolation(data: typing.BinaryIO, property_size: int):
return InterpolationMethod.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x42087650: ('priority', _decode_priority),
0x8747552e: ('timer', _decode_timer),
0x21d720a9: ('flags_camera_hint', _decode_flags_camera_hint),
0x97a93f8f: ('constraints', _decode_constraints),
0xd1bd5c40: ('position_behavior', _decode_position_behavior),
0x4be3494b: ('navigation_behavior', _decode_navigation_behavior),
0xebc3e775: ('motion_behavior', _decode_motion_behavior),
0x65fc11ff: ('orientation_behavior', _decode_orientation_behavior),
0xa7c38d: ('rotation_behavior', _decode_rotation_behavior),
0xfc126ad1: ('field_of_view_behavior', _decode_field_of_view_behavior),
0x764827d4: ('interpolation_behavior', _decode_interpolation_behavior),
0x95d0d437: ('control_frame_interpolation', _decode_control_frame_interpolation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CameraHint.py | 0.575469 | 0.286581 | CameraHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
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 CameraFilterKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
filter_type: int = dataclasses.field(default=0)
filter_shape: int = dataclasses.field(default=0)
filter_stage: int = dataclasses.field(default=0)
which_filter_group: int = dataclasses.field(default=0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
interpolate_in_time: float = dataclasses.field(default=0.0)
interpolate_out_time: float = dataclasses.field(default=0.0)
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FILT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'yu\xdb[') # 0x7975db5b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_type))
data.write(b'j>\x9a=') # 0x6a3e9a3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_shape))
data.write(b'X\xbd\xbd{') # 0x58bdbd7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_stage))
data.write(b'?\xdcK.') # 0x3fdc4b2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_filter_group))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\xab\xd4\x1a6') # 0xabd41a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_in_time))
data.write(b'>\xafx\xfe') # 0x3eaf78fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_out_time))
data.write(b'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
filter_type=data['filter_type'],
filter_shape=data['filter_shape'],
filter_stage=data['filter_stage'],
which_filter_group=data['which_filter_group'],
color=Color.from_json(data['color']),
interpolate_in_time=data['interpolate_in_time'],
interpolate_out_time=data['interpolate_out_time'],
texture=data['texture'],
model=data['model'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'filter_type': self.filter_type,
'filter_shape': self.filter_shape,
'filter_stage': self.filter_stage,
'which_filter_group': self.which_filter_group,
'color': self.color.to_json(),
'interpolate_in_time': self.interpolate_in_time,
'interpolate_out_time': self.interpolate_out_time,
'texture': self.texture,
'model': self.model,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_filter_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_filter_shape(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_filter_stage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_which_filter_group(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_interpolate_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_interpolate_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7975db5b: ('filter_type', _decode_filter_type),
0x6a3e9a3d: ('filter_shape', _decode_filter_shape),
0x58bdbd7b: ('filter_stage', _decode_filter_stage),
0x3fdc4b2e: ('which_filter_group', _decode_which_filter_group),
0x37c7d09d: ('color', _decode_color),
0xabd41a36: ('interpolate_in_time', _decode_interpolate_in_time),
0x3eaf78fe: ('interpolate_out_time', _decode_interpolate_out_time),
0xd1f65872: ('texture', _decode_texture),
0xc27ffa8f: ('model', _decode_model),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CameraFilterKeyframe.py | 0.625324 | 0.257345 | CameraFilterKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class VolGroup(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
group_name: str = dataclasses.field(default='')
volume: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'VOLG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'o\xe83=') # 0x6fe8333d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.group_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
group_name=data['group_name'],
volume=data['volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'group_name': self.group_name,
'volume': self.volume,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_group_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6fe8333d: ('group_name', _decode_group_name),
0xc7a7f189: ('volume', _decode_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/VolGroup.py | 0.621081 | 0.356083 | VolGroup.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.corruption.archetypes.CounterConditions import CounterConditions
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Counter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
initial_count: int = dataclasses.field(default=0)
max_count: int = dataclasses.field(default=4)
auto_reset: bool = dataclasses.field(default=False)
wrap: bool = dataclasses.field(default=False)
counter_conditions: CounterConditions = dataclasses.field(default_factory=CounterConditions)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CNTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x17\x9ao') # 0xfd179a6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_count))
data.write(b'[\x85\x15\x89') # 0x5b851589
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_count))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'\xf0v\xce\xf5') # 0xf076cef5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wrap))
data.write(b'\x9c\x1d3\xde') # 0x9c1d33de
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.counter_conditions.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
initial_count=data['initial_count'],
max_count=data['max_count'],
auto_reset=data['auto_reset'],
wrap=data['wrap'],
counter_conditions=CounterConditions.from_json(data['counter_conditions']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'initial_count': self.initial_count,
'max_count': self.max_count,
'auto_reset': self.auto_reset,
'wrap': self.wrap,
'counter_conditions': self.counter_conditions.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_initial_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_auto_reset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wrap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_counter_conditions(data: typing.BinaryIO, property_size: int):
return CounterConditions.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfd179a6f: ('initial_count', _decode_initial_count),
0x5b851589: ('max_count', _decode_max_count),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0xf076cef5: ('wrap', _decode_wrap),
0x9c1d33de: ('counter_conditions', _decode_counter_conditions),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Counter.py | 0.589716 | 0.32134 | Counter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class CannonBall(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'CANB'
@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'\xb6\x8cm\x96') # 0xb68c6d96
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.effect))
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']),
effect=data['effect'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'effect': self.effect,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_effect(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),
0xb68c6d96: ('effect', _decode_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CannonBall.py | 0.594198 | 0.318022 | CannonBall.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.WeaponGeneratorProperties import WeaponGeneratorProperties
@dataclasses.dataclass()
class WeaponGenerator(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
weapon_generator_properties: WeaponGeneratorProperties = dataclasses.field(default_factory=WeaponGeneratorProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'WPNG'
@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'?\x0013') # 0x3f003133
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weapon_generator_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']),
weapon_generator_properties=WeaponGeneratorProperties.from_json(data['weapon_generator_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'weapon_generator_properties': self.weapon_generator_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_weapon_generator_properties(data: typing.BinaryIO, property_size: int):
return WeaponGeneratorProperties.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),
0x3f003133: ('weapon_generator_properties', _decode_weapon_generator_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WeaponGenerator.py | 0.593138 | 0.327615 | WeaponGenerator.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.UnknownStruct65 import UnknownStruct65
@dataclasses.dataclass()
class WorldTeleporterAttributes(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct65: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xfae81682: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x5f63868c: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x91337a24: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x34b8ea2a: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x01555c79: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xa4decc77: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x4685a368: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xe30e3366: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xee37cd3c: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x4bbc5d32: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x7e51eb61: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xdbda7b6f: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x158a87c7: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xb00117c9: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x85eca19a: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x20673194: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0xc23c5e8b: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x67b7ce85: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
unknown_0x1c6020c4: UnknownStruct65 = dataclasses.field(default_factory=UnknownStruct65)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'WTAT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptWorldTeleporterAttributes.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\x0f') # 15 properties
num_properties_written = 15
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\x05\xa0\xd1') # 0xcf05a0d1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct65.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa\xe8\x16\x82') # 0xfae81682
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xfae81682.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'_c\x86\x8c') # 0x5f63868c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x5f63868c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x913z$') # 0x91337a24
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x91337a24.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'4\xb8\xea*') # 0x34b8ea2a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x34b8ea2a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x01U\\y') # 0x1555c79
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x01555c79.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4\xde\xccw') # 0xa4decc77
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xa4decc77.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'F\x85\xa3h') # 0x4685a368
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x4685a368.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe3\x0e3f') # 0xe30e3366
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xe30e3366.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xee7\xcd<') # 0xee37cd3c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xee37cd3c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'K\xbc]2') # 0x4bbc5d32
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x4bbc5d32.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~Q\xeba') # 0x7e51eb61
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7e51eb61.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdb\xda{o') # 0xdbda7b6f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xdbda7b6f.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15\x8a\x87\xc7') # 0x158a87c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x158a87c7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0xb00117c9 != default_override.get('unknown_0xb00117c9', UnknownStruct65()):
num_properties_written += 1
data.write(b'\xb0\x01\x17\xc9') # 0xb00117c9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb00117c9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x85eca19a != default_override.get('unknown_0x85eca19a', UnknownStruct65()):
num_properties_written += 1
data.write(b'\x85\xec\xa1\x9a') # 0x85eca19a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x85eca19a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x20673194 != default_override.get('unknown_0x20673194', UnknownStruct65()):
num_properties_written += 1
data.write(b' g1\x94') # 0x20673194
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x20673194.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0xc23c5e8b != default_override.get('unknown_0xc23c5e8b', UnknownStruct65()):
num_properties_written += 1
data.write(b'\xc2<^\x8b') # 0xc23c5e8b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xc23c5e8b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x67b7ce85 != default_override.get('unknown_0x67b7ce85', UnknownStruct65()):
num_properties_written += 1
data.write(b'g\xb7\xce\x85') # 0x67b7ce85
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x67b7ce85.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x1c6020c4 != default_override.get('unknown_0x1c6020c4', UnknownStruct65()):
num_properties_written += 1
data.write(b'\x1c` \xc4') # 0x1c6020c4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1c6020c4.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.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct65=UnknownStruct65.from_json(data['unknown_struct65']),
unknown_0xfae81682=UnknownStruct65.from_json(data['unknown_0xfae81682']),
unknown_0x5f63868c=UnknownStruct65.from_json(data['unknown_0x5f63868c']),
unknown_0x91337a24=UnknownStruct65.from_json(data['unknown_0x91337a24']),
unknown_0x34b8ea2a=UnknownStruct65.from_json(data['unknown_0x34b8ea2a']),
unknown_0x01555c79=UnknownStruct65.from_json(data['unknown_0x01555c79']),
unknown_0xa4decc77=UnknownStruct65.from_json(data['unknown_0xa4decc77']),
unknown_0x4685a368=UnknownStruct65.from_json(data['unknown_0x4685a368']),
unknown_0xe30e3366=UnknownStruct65.from_json(data['unknown_0xe30e3366']),
unknown_0xee37cd3c=UnknownStruct65.from_json(data['unknown_0xee37cd3c']),
unknown_0x4bbc5d32=UnknownStruct65.from_json(data['unknown_0x4bbc5d32']),
unknown_0x7e51eb61=UnknownStruct65.from_json(data['unknown_0x7e51eb61']),
unknown_0xdbda7b6f=UnknownStruct65.from_json(data['unknown_0xdbda7b6f']),
unknown_0x158a87c7=UnknownStruct65.from_json(data['unknown_0x158a87c7']),
unknown_0xb00117c9=UnknownStruct65.from_json(data['unknown_0xb00117c9']),
unknown_0x85eca19a=UnknownStruct65.from_json(data['unknown_0x85eca19a']),
unknown_0x20673194=UnknownStruct65.from_json(data['unknown_0x20673194']),
unknown_0xc23c5e8b=UnknownStruct65.from_json(data['unknown_0xc23c5e8b']),
unknown_0x67b7ce85=UnknownStruct65.from_json(data['unknown_0x67b7ce85']),
unknown_0x1c6020c4=UnknownStruct65.from_json(data['unknown_0x1c6020c4']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct65': self.unknown_struct65.to_json(),
'unknown_0xfae81682': self.unknown_0xfae81682.to_json(),
'unknown_0x5f63868c': self.unknown_0x5f63868c.to_json(),
'unknown_0x91337a24': self.unknown_0x91337a24.to_json(),
'unknown_0x34b8ea2a': self.unknown_0x34b8ea2a.to_json(),
'unknown_0x01555c79': self.unknown_0x01555c79.to_json(),
'unknown_0xa4decc77': self.unknown_0xa4decc77.to_json(),
'unknown_0x4685a368': self.unknown_0x4685a368.to_json(),
'unknown_0xe30e3366': self.unknown_0xe30e3366.to_json(),
'unknown_0xee37cd3c': self.unknown_0xee37cd3c.to_json(),
'unknown_0x4bbc5d32': self.unknown_0x4bbc5d32.to_json(),
'unknown_0x7e51eb61': self.unknown_0x7e51eb61.to_json(),
'unknown_0xdbda7b6f': self.unknown_0xdbda7b6f.to_json(),
'unknown_0x158a87c7': self.unknown_0x158a87c7.to_json(),
'unknown_0xb00117c9': self.unknown_0xb00117c9.to_json(),
'unknown_0x85eca19a': self.unknown_0x85eca19a.to_json(),
'unknown_0x20673194': self.unknown_0x20673194.to_json(),
'unknown_0xc23c5e8b': self.unknown_0xc23c5e8b.to_json(),
'unknown_0x67b7ce85': self.unknown_0x67b7ce85.to_json(),
'unknown_0x1c6020c4': self.unknown_0x1c6020c4.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct65(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xfae81682(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x5f63868c(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x91337a24(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x34b8ea2a(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x01555c79(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xa4decc77(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x4685a368(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xe30e3366(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xee37cd3c(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x4bbc5d32(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x7e51eb61(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xdbda7b6f(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x158a87c7(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xb00117c9(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x85eca19a(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x20673194(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0xc23c5e8b(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x67b7ce85(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
def _decode_unknown_0x1c6020c4(data: typing.BinaryIO, property_size: int):
return UnknownStruct65.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcf05a0d1: ('unknown_struct65', _decode_unknown_struct65),
0xfae81682: ('unknown_0xfae81682', _decode_unknown_0xfae81682),
0x5f63868c: ('unknown_0x5f63868c', _decode_unknown_0x5f63868c),
0x91337a24: ('unknown_0x91337a24', _decode_unknown_0x91337a24),
0x34b8ea2a: ('unknown_0x34b8ea2a', _decode_unknown_0x34b8ea2a),
0x1555c79: ('unknown_0x01555c79', _decode_unknown_0x01555c79),
0xa4decc77: ('unknown_0xa4decc77', _decode_unknown_0xa4decc77),
0x4685a368: ('unknown_0x4685a368', _decode_unknown_0x4685a368),
0xe30e3366: ('unknown_0xe30e3366', _decode_unknown_0xe30e3366),
0xee37cd3c: ('unknown_0xee37cd3c', _decode_unknown_0xee37cd3c),
0x4bbc5d32: ('unknown_0x4bbc5d32', _decode_unknown_0x4bbc5d32),
0x7e51eb61: ('unknown_0x7e51eb61', _decode_unknown_0x7e51eb61),
0xdbda7b6f: ('unknown_0xdbda7b6f', _decode_unknown_0xdbda7b6f),
0x158a87c7: ('unknown_0x158a87c7', _decode_unknown_0x158a87c7),
0xb00117c9: ('unknown_0xb00117c9', _decode_unknown_0xb00117c9),
0x85eca19a: ('unknown_0x85eca19a', _decode_unknown_0x85eca19a),
0x20673194: ('unknown_0x20673194', _decode_unknown_0x20673194),
0xc23c5e8b: ('unknown_0xc23c5e8b', _decode_unknown_0xc23c5e8b),
0x67b7ce85: ('unknown_0x67b7ce85', _decode_unknown_0x67b7ce85),
0x1c6020c4: ('unknown_0x1c6020c4', _decode_unknown_0x1c6020c4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WorldTeleporterAttributes.py | 0.518546 | 0.238916 | WorldTeleporterAttributes.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.UnknownStruct66 import UnknownStruct66
@dataclasses.dataclass()
class WorldTransitionChoiceRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
num_choices: int = dataclasses.field(default=1)
unknown_struct66: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0x6bb71e37: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0xfec7caa2: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0xa277e9cb: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0x37073d5e: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0x53e746a0: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0xc6979235: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0xea870072: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0x7ff7d4e7: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
unknown_0x7db5008c: UnknownStruct66 = dataclasses.field(default_factory=UnknownStruct66)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'WTCR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptWorldTeleporter.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
num_properties_written = 3
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\xb2\xa4\x9b') # 0x58b2a49b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_choices))
data.write(b'\x0fWe\xc9') # 0xf5765c9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct66.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x6bb71e37 != default_override.get('unknown_0x6bb71e37', UnknownStruct66()):
num_properties_written += 1
data.write(b'k\xb7\x1e7') # 0x6bb71e37
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x6bb71e37.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0xfec7caa2 != default_override.get('unknown_0xfec7caa2', UnknownStruct66()):
num_properties_written += 1
data.write(b'\xfe\xc7\xca\xa2') # 0xfec7caa2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xfec7caa2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0xa277e9cb != default_override.get('unknown_0xa277e9cb', UnknownStruct66()):
num_properties_written += 1
data.write(b'\xa2w\xe9\xcb') # 0xa277e9cb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xa277e9cb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x37073d5e != default_override.get('unknown_0x37073d5e', UnknownStruct66()):
num_properties_written += 1
data.write(b'7\x07=^') # 0x37073d5e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x37073d5e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x53e746a0 != default_override.get('unknown_0x53e746a0', UnknownStruct66()):
num_properties_written += 1
data.write(b'S\xe7F\xa0') # 0x53e746a0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x53e746a0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0xc6979235 != default_override.get('unknown_0xc6979235', UnknownStruct66()):
num_properties_written += 1
data.write(b'\xc6\x97\x925') # 0xc6979235
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xc6979235.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0xea870072 != default_override.get('unknown_0xea870072', UnknownStruct66()):
num_properties_written += 1
data.write(b'\xea\x87\x00r') # 0xea870072
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xea870072.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x7ff7d4e7 != default_override.get('unknown_0x7ff7d4e7', UnknownStruct66()):
num_properties_written += 1
data.write(b'\x7f\xf7\xd4\xe7') # 0x7ff7d4e7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7ff7d4e7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.unknown_0x7db5008c != default_override.get('unknown_0x7db5008c', UnknownStruct66()):
num_properties_written += 1
data.write(b'}\xb5\x00\x8c') # 0x7db5008c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x7db5008c.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.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
num_choices=data['num_choices'],
unknown_struct66=UnknownStruct66.from_json(data['unknown_struct66']),
unknown_0x6bb71e37=UnknownStruct66.from_json(data['unknown_0x6bb71e37']),
unknown_0xfec7caa2=UnknownStruct66.from_json(data['unknown_0xfec7caa2']),
unknown_0xa277e9cb=UnknownStruct66.from_json(data['unknown_0xa277e9cb']),
unknown_0x37073d5e=UnknownStruct66.from_json(data['unknown_0x37073d5e']),
unknown_0x53e746a0=UnknownStruct66.from_json(data['unknown_0x53e746a0']),
unknown_0xc6979235=UnknownStruct66.from_json(data['unknown_0xc6979235']),
unknown_0xea870072=UnknownStruct66.from_json(data['unknown_0xea870072']),
unknown_0x7ff7d4e7=UnknownStruct66.from_json(data['unknown_0x7ff7d4e7']),
unknown_0x7db5008c=UnknownStruct66.from_json(data['unknown_0x7db5008c']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'num_choices': self.num_choices,
'unknown_struct66': self.unknown_struct66.to_json(),
'unknown_0x6bb71e37': self.unknown_0x6bb71e37.to_json(),
'unknown_0xfec7caa2': self.unknown_0xfec7caa2.to_json(),
'unknown_0xa277e9cb': self.unknown_0xa277e9cb.to_json(),
'unknown_0x37073d5e': self.unknown_0x37073d5e.to_json(),
'unknown_0x53e746a0': self.unknown_0x53e746a0.to_json(),
'unknown_0xc6979235': self.unknown_0xc6979235.to_json(),
'unknown_0xea870072': self.unknown_0xea870072.to_json(),
'unknown_0x7ff7d4e7': self.unknown_0x7ff7d4e7.to_json(),
'unknown_0x7db5008c': self.unknown_0x7db5008c.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_num_choices(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_struct66(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0x6bb71e37(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0xfec7caa2(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0xa277e9cb(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0x37073d5e(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0x53e746a0(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0xc6979235(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0xea870072(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0x7ff7d4e7(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.from_stream(data, property_size)
def _decode_unknown_0x7db5008c(data: typing.BinaryIO, property_size: int):
return UnknownStruct66.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),
0x58b2a49b: ('num_choices', _decode_num_choices),
0xf5765c9: ('unknown_struct66', _decode_unknown_struct66),
0x6bb71e37: ('unknown_0x6bb71e37', _decode_unknown_0x6bb71e37),
0xfec7caa2: ('unknown_0xfec7caa2', _decode_unknown_0xfec7caa2),
0xa277e9cb: ('unknown_0xa277e9cb', _decode_unknown_0xa277e9cb),
0x37073d5e: ('unknown_0x37073d5e', _decode_unknown_0x37073d5e),
0x53e746a0: ('unknown_0x53e746a0', _decode_unknown_0x53e746a0),
0xc6979235: ('unknown_0xc6979235', _decode_unknown_0xc6979235),
0xea870072: ('unknown_0xea870072', _decode_unknown_0xea870072),
0x7ff7d4e7: ('unknown_0x7ff7d4e7', _decode_unknown_0x7ff7d4e7),
0x7db5008c: ('unknown_0x7db5008c', _decode_unknown_0x7db5008c),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WorldTransitionChoiceRelay.py | 0.490236 | 0.280798 | WorldTransitionChoiceRelay.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PhazonPuddleData import PhazonPuddleData
@dataclasses.dataclass()
class PhazonPuddle(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
phazon_puddle_properties: PhazonPuddleData = dataclasses.field(default_factory=PhazonPuddleData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PPDL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MinorIng.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'o;\xb6%') # 0x6f3bb625
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phazon_puddle_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
phazon_puddle_properties=PhazonPuddleData.from_json(data['phazon_puddle_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'phazon_puddle_properties': self.phazon_puddle_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_phazon_puddle_properties(data: typing.BinaryIO, property_size: int):
return PhazonPuddleData.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),
0x6f3bb625: ('phazon_puddle_properties', _decode_phazon_puddle_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhazonPuddle.py | 0.659076 | 0.329459 | PhazonPuddle.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PlatformMotionProperties import PlatformMotionProperties
@dataclasses.dataclass()
class ShipCommandPath(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
motion_properties: PlatformMotionProperties = dataclasses.field(default_factory=PlatformMotionProperties)
unknown_0x8df64d50: bool = dataclasses.field(default=False)
stick_to_spline: bool = dataclasses.field(default=False)
unknown_0x04c4e40b: bool = dataclasses.field(default=True)
path_range: float = dataclasses.field(default=50.0)
path_cone_angle: float = dataclasses.field(default=360.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SHCP'
@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'\n\x9d\xbf\x91') # 0xa9dbf91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d\xf6MP') # 0x8df64d50
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8df64d50))
data.write(b'\xd9R\xf5\x1a') # 0xd952f51a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stick_to_spline))
data.write(b'\x04\xc4\xe4\x0b') # 0x4c4e40b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x04c4e40b))
data.write(b'=F\xb7\x99') # 0x3d46b799
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.path_range))
data.write(b'\xae\x8d \xaa') # 0xae8d20aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.path_cone_angle))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
motion_properties=PlatformMotionProperties.from_json(data['motion_properties']),
unknown_0x8df64d50=data['unknown_0x8df64d50'],
stick_to_spline=data['stick_to_spline'],
unknown_0x04c4e40b=data['unknown_0x04c4e40b'],
path_range=data['path_range'],
path_cone_angle=data['path_cone_angle'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'motion_properties': self.motion_properties.to_json(),
'unknown_0x8df64d50': self.unknown_0x8df64d50,
'stick_to_spline': self.stick_to_spline,
'unknown_0x04c4e40b': self.unknown_0x04c4e40b,
'path_range': self.path_range,
'path_cone_angle': self.path_cone_angle,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_motion_properties(data: typing.BinaryIO, property_size: int):
return PlatformMotionProperties.from_stream(data, property_size)
def _decode_unknown_0x8df64d50(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_stick_to_spline(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x04c4e40b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_path_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_path_cone_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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa9dbf91: ('motion_properties', _decode_motion_properties),
0x8df64d50: ('unknown_0x8df64d50', _decode_unknown_0x8df64d50),
0xd952f51a: ('stick_to_spline', _decode_stick_to_spline),
0x4c4e40b: ('unknown_0x04c4e40b', _decode_unknown_0x04c4e40b),
0x3d46b799: ('path_range', _decode_path_range),
0xae8d20aa: ('path_cone_angle', _decode_path_cone_angle),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ShipCommandPath.py | 0.593845 | 0.349255 | ShipCommandPath.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.ShadowProjection import ShadowProjection
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class ShadowProjector(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_scale: float = dataclasses.field(default=1.0)
shadow_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
shadow_height: float = dataclasses.field(default=100.0)
shadow_alpha: float = dataclasses.field(default=0.5)
shadow_fade_time: float = dataclasses.field(default=1.0)
unknown_0xbca8b742: bool = dataclasses.field(default=False)
unknown_0x606e341c: int = dataclasses.field(default=128) # Flagset
unknown_struct510: ShadowProjection = dataclasses.field(default_factory=ShadowProjection)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SHDW'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x1d\x01\x1a9') # 0x1d011a39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_scale))
data.write(b'\xf3q\xedY') # 0xf371ed59
data.write(b'\x00\x0c') # size
self.shadow_offset.to_stream(data)
data.write(b'$\xec\x0f\xb0') # 0x24ec0fb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_height))
data.write(b'>,\xd3\x8d') # 0x3e2cd38d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_alpha))
data.write(b'\x8c\xcf6\xc0') # 0x8ccf36c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_fade_time))
data.write(b'\xbc\xa8\xb7B') # 0xbca8b742
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbca8b742))
data.write(b'`n4\x1c') # 0x606e341c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x606e341c))
data.write(b'\xa2\x1bQZ') # 0xa21b515a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct510.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_scale=data['shadow_scale'],
shadow_offset=Vector.from_json(data['shadow_offset']),
shadow_height=data['shadow_height'],
shadow_alpha=data['shadow_alpha'],
shadow_fade_time=data['shadow_fade_time'],
unknown_0xbca8b742=data['unknown_0xbca8b742'],
unknown_0x606e341c=data['unknown_0x606e341c'],
unknown_struct510=ShadowProjection.from_json(data['unknown_struct510']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_scale': self.shadow_scale,
'shadow_offset': self.shadow_offset.to_json(),
'shadow_height': self.shadow_height,
'shadow_alpha': self.shadow_alpha,
'shadow_fade_time': self.shadow_fade_time,
'unknown_0xbca8b742': self.unknown_0xbca8b742,
'unknown_0x606e341c': self.unknown_0x606e341c,
'unknown_struct510': self.unknown_struct510.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_shadow_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbca8b742(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x606e341c(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_struct510(data: typing.BinaryIO, property_size: int):
return ShadowProjection.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),
0x1d011a39: ('shadow_scale', _decode_shadow_scale),
0xf371ed59: ('shadow_offset', _decode_shadow_offset),
0x24ec0fb0: ('shadow_height', _decode_shadow_height),
0x3e2cd38d: ('shadow_alpha', _decode_shadow_alpha),
0x8ccf36c0: ('shadow_fade_time', _decode_shadow_fade_time),
0xbca8b742: ('unknown_0xbca8b742', _decode_unknown_0xbca8b742),
0x606e341c: ('unknown_0x606e341c', _decode_unknown_0x606e341c),
0xa21b515a: ('unknown_struct510', _decode_unknown_struct510),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ShadowProjector.py | 0.581184 | 0.30808 | ShadowProjector.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.corruption.archetypes.PlatformMotionProperties import PlatformMotionProperties
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.Vector import Vector
@dataclasses.dataclass()
class Platform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
x_ray_transparency: float = dataclasses.field(default=1.0)
maximum_splashes: int = dataclasses.field(default=200)
splash_generation_rate: int = dataclasses.field(default=20)
render_rain_splashes: bool = dataclasses.field(default=False)
unknown_0xf203bc81: bool = dataclasses.field(default=False)
motion_properties: PlatformMotionProperties = dataclasses.field(default_factory=PlatformMotionProperties)
unknown_0x24fdeea1: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.15000000596046448, z=0.0))
random_animation_offset: float = dataclasses.field(default=0.0)
orbit_offset_local: bool = dataclasses.field(default=True)
orbit_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x6b5e87a7: float = dataclasses.field(default=1800.0)
look_at_velocity: float = dataclasses.field(default=30.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PLAT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x15') # 21 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'aP\xd6\x87') # 0x6150d687
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.x_ray_transparency))
data.write(b'\xdc\xd5o\xe8') # 0xdcd56fe8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.maximum_splashes))
data.write(b'h-\xe1\\') # 0x682de15c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.splash_generation_rate))
data.write(b'\xac:\xdd\xa6') # 0xac3adda6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_rain_splashes))
data.write(b'\xf2\x03\xbc\x81') # 0xf203bc81
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf203bc81))
data.write(b'\n\x9d\xbf\x91') # 0xa9dbf91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xfd\xee\xa1') # 0x24fdeea1
data.write(b'\x00\x0c') # size
self.unknown_0x24fdeea1.to_stream(data)
data.write(b'\xbfi\xc0>') # 0xbf69c03e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_animation_offset))
data.write(b'\xe7?\x12=') # 0xe73f123d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orbit_offset_local))
data.write(b'\x85\x01\x15\xe4') # 0x850115e4
data.write(b'\x00\x0c') # size
self.orbit_offset.to_stream(data)
data.write(b'k^\x87\xa7') # 0x6b5e87a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6b5e87a7))
data.write(b'=\xc7W3') # 0x3dc75733
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_at_velocity))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
model=data['model'],
animation=AnimationParameters.from_json(data['animation']),
actor_information=ActorParameters.from_json(data['actor_information']),
collision_model=data['collision_model'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
x_ray_transparency=data['x_ray_transparency'],
maximum_splashes=data['maximum_splashes'],
splash_generation_rate=data['splash_generation_rate'],
render_rain_splashes=data['render_rain_splashes'],
unknown_0xf203bc81=data['unknown_0xf203bc81'],
motion_properties=PlatformMotionProperties.from_json(data['motion_properties']),
unknown_0x24fdeea1=Vector.from_json(data['unknown_0x24fdeea1']),
random_animation_offset=data['random_animation_offset'],
orbit_offset_local=data['orbit_offset_local'],
orbit_offset=Vector.from_json(data['orbit_offset']),
unknown_0x6b5e87a7=data['unknown_0x6b5e87a7'],
look_at_velocity=data['look_at_velocity'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'model': self.model,
'animation': self.animation.to_json(),
'actor_information': self.actor_information.to_json(),
'collision_model': self.collision_model,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'x_ray_transparency': self.x_ray_transparency,
'maximum_splashes': self.maximum_splashes,
'splash_generation_rate': self.splash_generation_rate,
'render_rain_splashes': self.render_rain_splashes,
'unknown_0xf203bc81': self.unknown_0xf203bc81,
'motion_properties': self.motion_properties.to_json(),
'unknown_0x24fdeea1': self.unknown_0x24fdeea1.to_json(),
'random_animation_offset': self.random_animation_offset,
'orbit_offset_local': self.orbit_offset_local,
'orbit_offset': self.orbit_offset.to_json(),
'unknown_0x6b5e87a7': self.unknown_0x6b5e87a7,
'look_at_velocity': self.look_at_velocity,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_x_ray_transparency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_splash_generation_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_render_rain_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf203bc81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_properties(data: typing.BinaryIO, property_size: int):
return PlatformMotionProperties.from_stream(data, property_size)
def _decode_unknown_0x24fdeea1(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_random_animation_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_orbit_offset_local(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_orbit_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x6b5e87a7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_at_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xc27ffa8f: ('model', _decode_model),
0xa3d63f44: ('animation', _decode_animation),
0x7e397fed: ('actor_information', _decode_actor_information),
0xfc966dc: ('collision_model', _decode_collision_model),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x6150d687: ('x_ray_transparency', _decode_x_ray_transparency),
0xdcd56fe8: ('maximum_splashes', _decode_maximum_splashes),
0x682de15c: ('splash_generation_rate', _decode_splash_generation_rate),
0xac3adda6: ('render_rain_splashes', _decode_render_rain_splashes),
0xf203bc81: ('unknown_0xf203bc81', _decode_unknown_0xf203bc81),
0xa9dbf91: ('motion_properties', _decode_motion_properties),
0x24fdeea1: ('unknown_0x24fdeea1', _decode_unknown_0x24fdeea1),
0xbf69c03e: ('random_animation_offset', _decode_random_animation_offset),
0xe73f123d: ('orbit_offset_local', _decode_orbit_offset_local),
0x850115e4: ('orbit_offset', _decode_orbit_offset),
0x6b5e87a7: ('unknown_0x6b5e87a7', _decode_unknown_0x6b5e87a7),
0x3dc75733: ('look_at_velocity', _decode_look_at_velocity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Platform.py | 0.638046 | 0.283918 | Platform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.DebrisProperties import DebrisProperties
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Debris(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
debris_properties: DebrisProperties = dataclasses.field(default_factory=DebrisProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DEBR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8a\x1c\x82\x1d') # 0x8a1c821d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.debris_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
debris_properties=DebrisProperties.from_json(data['debris_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'debris_properties': self.debris_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_debris_properties(data: typing.BinaryIO, property_size: int):
return DebrisProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x8a1c821d: ('debris_properties', _decode_debris_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Debris.py | 0.650356 | 0.300188 | Debris.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.PhaazoidData import PhaazoidData
@dataclasses.dataclass()
class Phaazoid(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
phaazoid_data: PhaazoidData = dataclasses.field(default_factory=PhaazoidData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PHZD'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Phaazoid.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'\xa9+\xfe\x03') # 0xa92bfe03
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phaazoid_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']),
actor_information=ActorParameters.from_json(data['actor_information']),
phaazoid_data=PhaazoidData.from_json(data['phaazoid_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'phaazoid_data': self.phaazoid_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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_phaazoid_data(data: typing.BinaryIO, property_size: int):
return PhaazoidData.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa92bfe03: ('phaazoid_data', _decode_phaazoid_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Phaazoid.py | 0.615897 | 0.356279 | Phaazoid.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PhysicsDebrisProperties import PhysicsDebrisProperties
@dataclasses.dataclass()
class PhysicsDebris(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
physics_debris_properties: PhysicsDebrisProperties = dataclasses.field(default_factory=PhysicsDebrisProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PDBR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptPhysicsDebris.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd9ML\xa3') # 0xd94d4ca3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.physics_debris_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
physics_debris_properties=PhysicsDebrisProperties.from_json(data['physics_debris_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'physics_debris_properties': self.physics_debris_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_physics_debris_properties(data: typing.BinaryIO, property_size: int):
return PhysicsDebrisProperties.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),
0xd94d4ca3: ('physics_debris_properties', _decode_physics_debris_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhysicsDebris.py | 0.651355 | 0.308822 | PhysicsDebris.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation_index: int = dataclasses.field(default=0)
unknown_0xc215a24f: int = dataclasses.field(default=0)
loop: bool = dataclasses.field(default=False)
loop_duration: float = dataclasses.field(default=0.0)
unknown_0x6d62ef74: int = dataclasses.field(default=0)
playback_rate: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIKF'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x1c\xcd\x05\x86') # 0x1ccd0586
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation_index))
data.write(b'\xc2\x15\xa2O') # 0xc215a24f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc215a24f))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\xce\xe6\x87#') # 0xcee68723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.loop_duration))
data.write(b'mb\xeft') # 0x6d62ef74
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6d62ef74))
data.write(b'o\x8d4\xca') # 0x6f8d34ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.playback_rate))
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']),
animation_index=data['animation_index'],
unknown_0xc215a24f=data['unknown_0xc215a24f'],
loop=data['loop'],
loop_duration=data['loop_duration'],
unknown_0x6d62ef74=data['unknown_0x6d62ef74'],
playback_rate=data['playback_rate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation_index': self.animation_index,
'unknown_0xc215a24f': self.unknown_0xc215a24f,
'loop': self.loop,
'loop_duration': self.loop_duration,
'unknown_0x6d62ef74': self.unknown_0x6d62ef74,
'playback_rate': self.playback_rate,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_animation_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc215a24f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6d62ef74(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_playback_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x1ccd0586: ('animation_index', _decode_animation_index),
0xc215a24f: ('unknown_0xc215a24f', _decode_unknown_0xc215a24f),
0xeda47ff6: ('loop', _decode_loop),
0xcee68723: ('loop_duration', _decode_loop_duration),
0x6d62ef74: ('unknown_0x6d62ef74', _decode_unknown_0x6d62ef74),
0x6f8d34ca: ('playback_rate', _decode_playback_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AIKeyframe.py | 0.610453 | 0.322606 | AIKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.SteamBotData import SteamBotData
@dataclasses.dataclass()
class SteamBot(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
steam_bot_data: SteamBotData = dataclasses.field(default_factory=SteamBotData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'STMB'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SteamBot.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'\x117^\xc0') # 0x11375ec0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.steam_bot_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
steam_bot_data=SteamBotData.from_json(data['steam_bot_data']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'steam_bot_data': self.steam_bot_data.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_steam_bot_data(data: typing.BinaryIO, property_size: int):
return SteamBotData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x11375ec0: ('steam_bot_data', _decode_steam_bot_data),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SteamBot.py | 0.596198 | 0.348451 | SteamBot.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct61 import UnknownStruct61
@dataclasses.dataclass()
class SteamDrone(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct61: UnknownStruct61 = dataclasses.field(default_factory=UnknownStruct61)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SDRN'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SteamDrone.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'\xa2?\x16\x1c') # 0xa23f161c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct61.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct61=UnknownStruct61.from_json(data['unknown_struct61']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct61': self.unknown_struct61.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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct61(data: typing.BinaryIO, property_size: int):
return UnknownStruct61.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa23f161c: ('unknown_struct61', _decode_unknown_struct61),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SteamDrone.py | 0.624752 | 0.338214 | SteamDrone.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.corruption.archetypes.CameraShakerData import CameraShakerData
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CameraShaker(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shaker_data: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CAMS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xadT\x7f\x96') # 0xad547f96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shaker_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shaker_data=CameraShakerData.from_json(data['shaker_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shaker_data': self.shaker_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shaker_data(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xad547f96: ('shaker_data', _decode_shaker_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CameraShaker.py | 0.644673 | 0.370852 | CameraShaker.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.OptionalAreaAssetTypes import OptionalAreaAssetTypes
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class OptionalAreaAsset(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
optional_area_asset_types: OptionalAreaAssetTypes = dataclasses.field(default_factory=OptionalAreaAssetTypes)
asset: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'OPAA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xf4Jh') # 0xff44a68
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.optional_area_asset_types.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0bL\x13\xa0') # 0xb4c13a0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.asset))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
optional_area_asset_types=OptionalAreaAssetTypes.from_json(data['optional_area_asset_types']),
asset=data['asset'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'optional_area_asset_types': self.optional_area_asset_types.to_json(),
'asset': self.asset,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_optional_area_asset_types(data: typing.BinaryIO, property_size: int):
return OptionalAreaAssetTypes.from_stream(data, property_size)
def _decode_asset(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xff44a68: ('optional_area_asset_types', _decode_optional_area_asset_types),
0xb4c13a0: ('asset', _decode_asset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/OptionalAreaAsset.py | 0.6973 | 0.291633 | OptionalAreaAsset.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.FederationData import FederationData
from retro_data_structures.properties.corruption.archetypes.FriendlyData import FriendlyData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class Friendly(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
friendly_properties: FriendlyData = dataclasses.field(default_factory=FriendlyData)
federation_properties: FederationData = dataclasses.field(default_factory=FederationData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'FRND'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Friendly.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'step_up_height': 1.0, 'creature_size': 1, 'leash_radius': 100.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf\x9b\xa6\xcc') # 0xbf9ba6cc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.friendly_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\xc2\xfd\xdf') # 0xbcc2fddf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.federation_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
friendly_properties=FriendlyData.from_json(data['friendly_properties']),
federation_properties=FederationData.from_json(data['federation_properties']),
)
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(),
'friendly_properties': self.friendly_properties.to_json(),
'federation_properties': self.federation_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'step_up_height': 1.0, 'creature_size': 1, 'leash_radius': 100.0})
def _decode_friendly_properties(data: typing.BinaryIO, property_size: int):
return FriendlyData.from_stream(data, property_size)
def _decode_federation_properties(data: typing.BinaryIO, property_size: int):
return FederationData.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),
0xbf9ba6cc: ('friendly_properties', _decode_friendly_properties),
0xbcc2fddf: ('federation_properties', _decode_federation_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Friendly.py | 0.663124 | 0.357231 | Friendly.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.RundasData import RundasData
from retro_data_structures.properties.corruption.archetypes.UnknownStruct55 import UnknownStruct55
@dataclasses.dataclass()
class Rundas(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct55: UnknownStruct55 = dataclasses.field(default_factory=UnknownStruct55)
rundas_data_0x9d90d49f: RundasData = dataclasses.field(default_factory=RundasData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
rundas_data_0x877b2ce9: RundasData = dataclasses.field(default_factory=RundasData)
patterned_ai_0x1464ae05: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
rundas_data_0xce6183d8: RundasData = dataclasses.field(default_factory=RundasData)
patterned_ai_0x24d00673: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'RUND'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Rundas.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\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'\xa6y\x07\t') # 0xa6790709
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct55.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9d\x90\xd4\x9f') # 0x9d90d49f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rundas_data_0x9d90d49f.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={'leash_radius': 100.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x87{,\xe9') # 0x877b2ce9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rundas_data_0x877b2ce9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14d\xae\x05') # 0x1464ae05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x1464ae05.to_stream(data, default_override={'leash_radius': 100.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcea\x83\xd8') # 0xce6183d8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rundas_data_0xce6183d8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xd0\x06s') # 0x24d00673
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x24d00673.to_stream(data, default_override={'leash_radius': 100.0})
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)
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_struct55=UnknownStruct55.from_json(data['unknown_struct55']),
rundas_data_0x9d90d49f=RundasData.from_json(data['rundas_data_0x9d90d49f']),
patterned=PatternedAITypedef.from_json(data['patterned']),
rundas_data_0x877b2ce9=RundasData.from_json(data['rundas_data_0x877b2ce9']),
patterned_ai_0x1464ae05=PatternedAITypedef.from_json(data['patterned_ai_0x1464ae05']),
rundas_data_0xce6183d8=RundasData.from_json(data['rundas_data_0xce6183d8']),
patterned_ai_0x24d00673=PatternedAITypedef.from_json(data['patterned_ai_0x24d00673']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct55': self.unknown_struct55.to_json(),
'rundas_data_0x9d90d49f': self.rundas_data_0x9d90d49f.to_json(),
'patterned': self.patterned.to_json(),
'rundas_data_0x877b2ce9': self.rundas_data_0x877b2ce9.to_json(),
'patterned_ai_0x1464ae05': self.patterned_ai_0x1464ae05.to_json(),
'rundas_data_0xce6183d8': self.rundas_data_0xce6183d8.to_json(),
'patterned_ai_0x24d00673': self.patterned_ai_0x24d00673.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct55(data: typing.BinaryIO, property_size: int):
return UnknownStruct55.from_stream(data, property_size)
def _decode_rundas_data_0x9d90d49f(data: typing.BinaryIO, property_size: int):
return RundasData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'leash_radius': 100.0})
def _decode_rundas_data_0x877b2ce9(data: typing.BinaryIO, property_size: int):
return RundasData.from_stream(data, property_size)
def _decode_patterned_ai_0x1464ae05(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'leash_radius': 100.0})
def _decode_rundas_data_0xce6183d8(data: typing.BinaryIO, property_size: int):
return RundasData.from_stream(data, property_size)
def _decode_patterned_ai_0x24d00673(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'leash_radius': 100.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa6790709: ('unknown_struct55', _decode_unknown_struct55),
0x9d90d49f: ('rundas_data_0x9d90d49f', _decode_rundas_data_0x9d90d49f),
0xb3774750: ('patterned', _decode_patterned),
0x877b2ce9: ('rundas_data_0x877b2ce9', _decode_rundas_data_0x877b2ce9),
0x1464ae05: ('patterned_ai_0x1464ae05', _decode_patterned_ai_0x1464ae05),
0xce6183d8: ('rundas_data_0xce6183d8', _decode_rundas_data_0xce6183d8),
0x24d00673: ('patterned_ai_0x24d00673', _decode_patterned_ai_0x24d00673),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Rundas.py | 0.524638 | 0.407216 | Rundas.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class FalsePerspective(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
percentage_of_depth_range: float = dataclasses.field(default=0.0)
near_clip_plane: float = dataclasses.field(default=20.0)
far_clip_plane: float = dataclasses.field(default=8192.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FLPS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x7fpe\xd3') # 0x7f7065d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.percentage_of_depth_range))
data.write(b'\xf4\x81\x7f\x13') # 0xf4817f13
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.near_clip_plane))
data.write(b'\x84\xecJt') # 0x84ec4a74
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.far_clip_plane))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
percentage_of_depth_range=data['percentage_of_depth_range'],
near_clip_plane=data['near_clip_plane'],
far_clip_plane=data['far_clip_plane'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'percentage_of_depth_range': self.percentage_of_depth_range,
'near_clip_plane': self.near_clip_plane,
'far_clip_plane': self.far_clip_plane,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_percentage_of_depth_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_near_clip_plane(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_far_clip_plane(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7f7065d3: ('percentage_of_depth_range', _decode_percentage_of_depth_range),
0xf4817f13: ('near_clip_plane', _decode_near_clip_plane),
0x84ec4a74: ('far_clip_plane', _decode_far_clip_plane),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FalsePerspective.py | 0.666822 | 0.387082 | FalsePerspective.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class PathMeshCtrl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
type: int = dataclasses.field(default=0)
initial_count: int = dataclasses.field(default=1)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PMCT'
@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'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
data.write(b'zn\r\xe9') # 0x7a6e0de9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_count))
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']),
type=data['type'],
initial_count=data['initial_count'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'type': self.type,
'initial_count': self.initial_count,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_initial_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf53dcdd6: ('type', _decode_type),
0x7a6e0de9: ('initial_count', _decode_initial_count),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PathMeshCtrl.py | 0.613468 | 0.352035 | PathMeshCtrl.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.KorbaMawData import KorbaMawData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class KorbaMaw(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
korba_maw_properties: KorbaMawData = dataclasses.field(default_factory=KorbaMawData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'KRBM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_KorbaMaw.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'3\xd8\xed\xe3') # 0x33d8ede3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.korba_maw_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_height': 0.5, 'step_up_height': 1.0, 'creature_size': 1, 'leash_radius': 100.0})
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)
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']),
korba_maw_properties=KorbaMawData.from_json(data['korba_maw_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'korba_maw_properties': self.korba_maw_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_korba_maw_properties(data: typing.BinaryIO, property_size: int):
return KorbaMawData.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_height': 0.5, 'step_up_height': 1.0, 'creature_size': 1, 'leash_radius': 100.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x33d8ede3: ('korba_maw_properties', _decode_korba_maw_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/KorbaMaw.py | 0.610918 | 0.325588 | KorbaMaw.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.LayerID import LayerID
@dataclasses.dataclass()
class ScriptLayerController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
layer: LayerID = dataclasses.field(default_factory=LayerID)
is_dynamic: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SLCT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82I\xf6\xc7') # 0x8249f6c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\xa7\xd8\xb2') # 0x12a7d8b2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_dynamic))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
layer=LayerID.from_json(data['layer']),
is_dynamic=data['is_dynamic'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'layer': self.layer.to_json(),
'is_dynamic': self.is_dynamic,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_layer(data: typing.BinaryIO, property_size: int):
return LayerID.from_stream(data, property_size)
def _decode_is_dynamic(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x8249f6c7: ('layer', _decode_layer),
0x12a7d8b2: ('is_dynamic', _decode_is_dynamic),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ScriptLayerController.py | 0.617513 | 0.354126 | ScriptLayerController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.GandraydaData import GandraydaData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class Gandrayda(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
gandrayda_data_0xfee49b25: GandraydaData = dataclasses.field(default_factory=GandraydaData)
gandrayda_data_0x49b975e6: GandraydaData = dataclasses.field(default_factory=GandraydaData)
gandrayda_data_0x82439cba: GandraydaData = dataclasses.field(default_factory=GandraydaData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'GAND'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Gandrayda.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\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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'step_up_height': 1.0, 'creature_size': 1, 'turn_speed': 60.0})
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'\xfe\xe4\x9b%') # 0xfee49b25
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gandrayda_data_0xfee49b25.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'I\xb9u\xe6') # 0x49b975e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gandrayda_data_0x49b975e6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82C\x9c\xba') # 0x82439cba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gandrayda_data_0x82439cba.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']),
actor_information=ActorParameters.from_json(data['actor_information']),
gandrayda_data_0xfee49b25=GandraydaData.from_json(data['gandrayda_data_0xfee49b25']),
gandrayda_data_0x49b975e6=GandraydaData.from_json(data['gandrayda_data_0x49b975e6']),
gandrayda_data_0x82439cba=GandraydaData.from_json(data['gandrayda_data_0x82439cba']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'gandrayda_data_0xfee49b25': self.gandrayda_data_0xfee49b25.to_json(),
'gandrayda_data_0x49b975e6': self.gandrayda_data_0x49b975e6.to_json(),
'gandrayda_data_0x82439cba': self.gandrayda_data_0x82439cba.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={'step_up_height': 1.0, 'creature_size': 1, 'turn_speed': 60.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_gandrayda_data_0xfee49b25(data: typing.BinaryIO, property_size: int):
return GandraydaData.from_stream(data, property_size)
def _decode_gandrayda_data_0x49b975e6(data: typing.BinaryIO, property_size: int):
return GandraydaData.from_stream(data, property_size)
def _decode_gandrayda_data_0x82439cba(data: typing.BinaryIO, property_size: int):
return GandraydaData.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xfee49b25: ('gandrayda_data_0xfee49b25', _decode_gandrayda_data_0xfee49b25),
0x49b975e6: ('gandrayda_data_0x49b975e6', _decode_gandrayda_data_0x49b975e6),
0x82439cba: ('gandrayda_data_0x82439cba', _decode_gandrayda_data_0x82439cba),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Gandrayda.py | 0.646014 | 0.413655 | Gandrayda.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.SeedBoss3Data import SeedBoss3Data
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class SeedBoss3(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
seed_boss3_data_0xfd27ed67: SeedBoss3Data = dataclasses.field(default_factory=SeedBoss3Data)
seed_boss3_data_0x5292969e: SeedBoss3Data = dataclasses.field(default_factory=SeedBoss3Data)
seed_boss3_data_0xcf9d77e8: SeedBoss3Data = dataclasses.field(default_factory=SeedBoss3Data)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
patterned_ai_0x5c056cef: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
patterned_ai_0x8be7ecb7: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'BOS3'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SeedBoss3.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\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"\xfd'\xedg") # 0xfd27ed67
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss3_data_0xfd27ed67.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'R\x92\x96\x9e') # 0x5292969e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss3_data_0x5292969e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcf\x9dw\xe8') # 0xcf9d77e8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss3_data_0xcf9d77e8.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={'mass': 1000.0, 'damage_wait_time': 0.009999999776482582, 'creature_size': 2, 'turn_speed': 90.0, 'grapple_icon_offset': Vector(x=0.0, y=2.0, z=-0.5)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\x05l\xef') # 0x5c056cef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x5c056cef.to_stream(data, default_override={'mass': 1000.0, 'damage_wait_time': 0.009999999776482582, 'creature_size': 2, 'turn_speed': 90.0, 'grapple_icon_offset': Vector(x=0.0, y=2.0, z=-0.5)})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xe7\xec\xb7') # 0x8be7ecb7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x8be7ecb7.to_stream(data, default_override={'mass': 1000.0, 'damage_wait_time': 0.009999999776482582, 'creature_size': 2, 'turn_speed': 90.0, 'grapple_icon_offset': Vector(x=0.0, y=2.0, z=-0.5)})
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)
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']),
seed_boss3_data_0xfd27ed67=SeedBoss3Data.from_json(data['seed_boss3_data_0xfd27ed67']),
seed_boss3_data_0x5292969e=SeedBoss3Data.from_json(data['seed_boss3_data_0x5292969e']),
seed_boss3_data_0xcf9d77e8=SeedBoss3Data.from_json(data['seed_boss3_data_0xcf9d77e8']),
patterned=PatternedAITypedef.from_json(data['patterned']),
patterned_ai_0x5c056cef=PatternedAITypedef.from_json(data['patterned_ai_0x5c056cef']),
patterned_ai_0x8be7ecb7=PatternedAITypedef.from_json(data['patterned_ai_0x8be7ecb7']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'seed_boss3_data_0xfd27ed67': self.seed_boss3_data_0xfd27ed67.to_json(),
'seed_boss3_data_0x5292969e': self.seed_boss3_data_0x5292969e.to_json(),
'seed_boss3_data_0xcf9d77e8': self.seed_boss3_data_0xcf9d77e8.to_json(),
'patterned': self.patterned.to_json(),
'patterned_ai_0x5c056cef': self.patterned_ai_0x5c056cef.to_json(),
'patterned_ai_0x8be7ecb7': self.patterned_ai_0x8be7ecb7.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_seed_boss3_data_0xfd27ed67(data: typing.BinaryIO, property_size: int):
return SeedBoss3Data.from_stream(data, property_size)
def _decode_seed_boss3_data_0x5292969e(data: typing.BinaryIO, property_size: int):
return SeedBoss3Data.from_stream(data, property_size)
def _decode_seed_boss3_data_0xcf9d77e8(data: typing.BinaryIO, property_size: int):
return SeedBoss3Data.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 1000.0, 'damage_wait_time': 0.009999999776482582, 'creature_size': 2, 'turn_speed': 90.0, 'grapple_icon_offset': Vector(x=0.0, y=2.0, z=-0.5)})
def _decode_patterned_ai_0x5c056cef(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 1000.0, 'damage_wait_time': 0.009999999776482582, 'creature_size': 2, 'turn_speed': 90.0, 'grapple_icon_offset': Vector(x=0.0, y=2.0, z=-0.5)})
def _decode_patterned_ai_0x8be7ecb7(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 1000.0, 'damage_wait_time': 0.009999999776482582, 'creature_size': 2, 'turn_speed': 90.0, 'grapple_icon_offset': Vector(x=0.0, y=2.0, z=-0.5)})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfd27ed67: ('seed_boss3_data_0xfd27ed67', _decode_seed_boss3_data_0xfd27ed67),
0x5292969e: ('seed_boss3_data_0x5292969e', _decode_seed_boss3_data_0x5292969e),
0xcf9d77e8: ('seed_boss3_data_0xcf9d77e8', _decode_seed_boss3_data_0xcf9d77e8),
0xb3774750: ('patterned', _decode_patterned),
0x5c056cef: ('patterned_ai_0x5c056cef', _decode_patterned_ai_0x5c056cef),
0x8be7ecb7: ('patterned_ai_0x8be7ecb7', _decode_patterned_ai_0x8be7ecb7),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SeedBoss3.py | 0.541166 | 0.379838 | SeedBoss3.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.PhazonLeechData import PhazonLeechData
@dataclasses.dataclass()
class PhazonLeech(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
phazon_leech_data: PhazonLeechData = dataclasses.field(default_factory=PhazonLeechData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PLCH'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PhazonLeech.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'\xca4\xb8>') # 0xca34b83e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phazon_leech_data.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={'detection_range': 50.0, 'min_attack_range': 10.0, 'max_attack_range': 20.0})
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)
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']),
phazon_leech_data=PhazonLeechData.from_json(data['phazon_leech_data']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'phazon_leech_data': self.phazon_leech_data.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_phazon_leech_data(data: typing.BinaryIO, property_size: int):
return PhazonLeechData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'detection_range': 50.0, 'min_attack_range': 10.0, 'max_attack_range': 20.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xca34b83e: ('phazon_leech_data', _decode_phazon_leech_data),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhazonLeech.py | 0.638385 | 0.321966 | PhazonLeech.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.SeedBoss2PrimeBotData import SeedBoss2PrimeBotData
from retro_data_structures.properties.corruption.archetypes.UnknownStruct58 import UnknownStruct58
@dataclasses.dataclass()
class SeedBoss2PrimeBot(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct58: UnknownStruct58 = dataclasses.field(default_factory=UnknownStruct58)
seed_boss2_prime_bot_data_0xb1461bc0: SeedBoss2PrimeBotData = dataclasses.field(default_factory=SeedBoss2PrimeBotData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
seed_boss2_prime_bot_data_0xd578f188: SeedBoss2PrimeBotData = dataclasses.field(default_factory=SeedBoss2PrimeBotData)
patterned_ai_0x1464ae05: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
seed_boss2_prime_bot_data_0xe3585b48: SeedBoss2PrimeBotData = dataclasses.field(default_factory=SeedBoss2PrimeBotData)
patterned_ai_0x24d00673: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SB2P'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SeedBoss2.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\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'\x96x(s') # 0x96782873
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct58.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb1F\x1b\xc0') # 0xb1461bc0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss2_prime_bot_data_0xb1461bc0.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd5x\xf1\x88') # 0xd578f188
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss2_prime_bot_data_0xd578f188.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14d\xae\x05') # 0x1464ae05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x1464ae05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe3X[H') # 0xe3585b48
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss2_prime_bot_data_0xe3585b48.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xd0\x06s') # 0x24d00673
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x24d00673.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)
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_struct58=UnknownStruct58.from_json(data['unknown_struct58']),
seed_boss2_prime_bot_data_0xb1461bc0=SeedBoss2PrimeBotData.from_json(data['seed_boss2_prime_bot_data_0xb1461bc0']),
patterned=PatternedAITypedef.from_json(data['patterned']),
seed_boss2_prime_bot_data_0xd578f188=SeedBoss2PrimeBotData.from_json(data['seed_boss2_prime_bot_data_0xd578f188']),
patterned_ai_0x1464ae05=PatternedAITypedef.from_json(data['patterned_ai_0x1464ae05']),
seed_boss2_prime_bot_data_0xe3585b48=SeedBoss2PrimeBotData.from_json(data['seed_boss2_prime_bot_data_0xe3585b48']),
patterned_ai_0x24d00673=PatternedAITypedef.from_json(data['patterned_ai_0x24d00673']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct58': self.unknown_struct58.to_json(),
'seed_boss2_prime_bot_data_0xb1461bc0': self.seed_boss2_prime_bot_data_0xb1461bc0.to_json(),
'patterned': self.patterned.to_json(),
'seed_boss2_prime_bot_data_0xd578f188': self.seed_boss2_prime_bot_data_0xd578f188.to_json(),
'patterned_ai_0x1464ae05': self.patterned_ai_0x1464ae05.to_json(),
'seed_boss2_prime_bot_data_0xe3585b48': self.seed_boss2_prime_bot_data_0xe3585b48.to_json(),
'patterned_ai_0x24d00673': self.patterned_ai_0x24d00673.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct58(data: typing.BinaryIO, property_size: int):
return UnknownStruct58.from_stream(data, property_size)
def _decode_seed_boss2_prime_bot_data_0xb1461bc0(data: typing.BinaryIO, property_size: int):
return SeedBoss2PrimeBotData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_seed_boss2_prime_bot_data_0xd578f188(data: typing.BinaryIO, property_size: int):
return SeedBoss2PrimeBotData.from_stream(data, property_size)
def _decode_patterned_ai_0x1464ae05(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_seed_boss2_prime_bot_data_0xe3585b48(data: typing.BinaryIO, property_size: int):
return SeedBoss2PrimeBotData.from_stream(data, property_size)
def _decode_patterned_ai_0x24d00673(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x96782873: ('unknown_struct58', _decode_unknown_struct58),
0xb1461bc0: ('seed_boss2_prime_bot_data_0xb1461bc0', _decode_seed_boss2_prime_bot_data_0xb1461bc0),
0xb3774750: ('patterned', _decode_patterned),
0xd578f188: ('seed_boss2_prime_bot_data_0xd578f188', _decode_seed_boss2_prime_bot_data_0xd578f188),
0x1464ae05: ('patterned_ai_0x1464ae05', _decode_patterned_ai_0x1464ae05),
0xe3585b48: ('seed_boss2_prime_bot_data_0xe3585b48', _decode_seed_boss2_prime_bot_data_0xe3585b48),
0x24d00673: ('patterned_ai_0x24d00673', _decode_patterned_ai_0x24d00673),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SeedBoss2PrimeBot.py | 0.501709 | 0.378861 | SeedBoss2PrimeBot.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.AiDifficultySettings import AiDifficultySettings
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct36 import UnknownStruct36
@dataclasses.dataclass()
class GhorLowerBody(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
ai_difficulty_settings: AiDifficultySettings = dataclasses.field(default_factory=AiDifficultySettings)
unknown_struct36: UnknownStruct36 = dataclasses.field(default_factory=UnknownStruct36)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'GHOR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Ghor.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Bi\x14\x90') # 0x42691490
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ai_difficulty_settings.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x99\xfd\x19o') # 0x99fd196f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct36.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
ai_difficulty_settings=AiDifficultySettings.from_json(data['ai_difficulty_settings']),
unknown_struct36=UnknownStruct36.from_json(data['unknown_struct36']),
)
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(),
'ai_difficulty_settings': self.ai_difficulty_settings.to_json(),
'unknown_struct36': self.unknown_struct36.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_ai_difficulty_settings(data: typing.BinaryIO, property_size: int):
return AiDifficultySettings.from_stream(data, property_size)
def _decode_unknown_struct36(data: typing.BinaryIO, property_size: int):
return UnknownStruct36.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x42691490: ('ai_difficulty_settings', _decode_ai_difficulty_settings),
0x99fd196f: ('unknown_struct36', _decode_unknown_struct36),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GhorLowerBody.py | 0.625896 | 0.369998 | GhorLowerBody.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.FlyerSwarmData import FlyerSwarmData
from retro_data_structures.properties.corruption.archetypes.SwarmBasicsData import SwarmBasicsData
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class FlyerSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
swarm_basics_data: SwarmBasicsData = dataclasses.field(default_factory=SwarmBasicsData)
flyer_swarm_data: FlyerSwarmData = dataclasses.field(default_factory=FlyerSwarmData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'FSWM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'L\xfcF\xfe') # 0x4cfc46fe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swarm_basics_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x99\xc1\x87\x02') # 0x99c18702
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flyer_swarm_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']),
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
active=data['active'],
swarm_basics_data=SwarmBasicsData.from_json(data['swarm_basics_data']),
flyer_swarm_data=FlyerSwarmData.from_json(data['flyer_swarm_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'character_animation_information': self.character_animation_information.to_json(),
'active': self.active,
'swarm_basics_data': self.swarm_basics_data.to_json(),
'flyer_swarm_data': self.flyer_swarm_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_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_swarm_basics_data(data: typing.BinaryIO, property_size: int):
return SwarmBasicsData.from_stream(data, property_size)
def _decode_flyer_swarm_data(data: typing.BinaryIO, property_size: int):
return FlyerSwarmData.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),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xc6bb2f45: ('active', _decode_active),
0x4cfc46fe: ('swarm_basics_data', _decode_swarm_basics_data),
0x99c18702: ('flyer_swarm_data', _decode_flyer_swarm_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FlyerSwarm.py | 0.618089 | 0.29821 | FlyerSwarm.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class SoundModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=5.0)
auto_reset: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
global_: 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.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SNDM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'$\t\xb9\x06') # 0x2409b906
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.global_))
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'],
auto_reset=data['auto_reset'],
auto_start=data['auto_start'],
global_=data['global_'],
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,
'auto_reset': self.auto_reset,
'auto_start': self.auto_start,
'global_': self.global_,
'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_auto_reset(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_global_(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),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0x3217dff8: ('auto_start', _decode_auto_start),
0x2409b906: ('global_', _decode_global_),
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/corruption/objects/SoundModifier.py | 0.574514 | 0.379378 | SoundModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Puffer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
is_orbitable: bool = dataclasses.field(default=True)
hover_speed: float = dataclasses.field(default=3.0)
cloud_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
cloud_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
cloud_steam: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
cloud_steam_alpha: float = dataclasses.field(default=0.5)
orbit_interpolant_followed: bool = dataclasses.field(default=True)
cloud_in_dark: bool = dataclasses.field(default=False)
cloud_in_echo: bool = dataclasses.field(default=False)
explosion_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
turn_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
death_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PUFR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Puffer.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\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'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82k\xec\x80') # 0x826bec80
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_orbitable))
data.write(b'\x84^\xf4\x89') # 0x845ef489
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_speed))
data.write(b'g\x0b\x9a\x1f') # 0x670b9a1f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cloud_effect))
data.write(b'\xe8a\x90\x82') # 0xe8619082
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cloud_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1a\xa4\x18\xf4') # 0x1aa418f4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.cloud_steam))
data.write(b'\xc9\xa5Ty') # 0xc9a55479
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cloud_steam_alpha))
data.write(b'\x98d\x7f ') # 0x98647f20
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orbit_interpolant_followed))
data.write(b'\x8a0\x11/') # 0x8a30112f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.cloud_in_dark))
data.write(b'\x86\xc8\x87\xa5') # 0x86c887a5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.cloud_in_echo))
data.write(b'\xde\xfft\xea') # 0xdeff74ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.explosion_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xc3\x94\x03') # 0xc4c39403
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.turn_sound))
data.write(b'\xc7\xc3\xf6\x10') # 0xc7c3f610
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_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']),
actor_information=ActorParameters.from_json(data['actor_information']),
patterned=PatternedAITypedef.from_json(data['patterned']),
is_orbitable=data['is_orbitable'],
hover_speed=data['hover_speed'],
cloud_effect=data['cloud_effect'],
cloud_damage=DamageInfo.from_json(data['cloud_damage']),
cloud_steam=data['cloud_steam'],
cloud_steam_alpha=data['cloud_steam_alpha'],
orbit_interpolant_followed=data['orbit_interpolant_followed'],
cloud_in_dark=data['cloud_in_dark'],
cloud_in_echo=data['cloud_in_echo'],
explosion_damage=DamageInfo.from_json(data['explosion_damage']),
turn_sound=data['turn_sound'],
death_sound=data['death_sound'],
)
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(),
'is_orbitable': self.is_orbitable,
'hover_speed': self.hover_speed,
'cloud_effect': self.cloud_effect,
'cloud_damage': self.cloud_damage.to_json(),
'cloud_steam': self.cloud_steam,
'cloud_steam_alpha': self.cloud_steam_alpha,
'orbit_interpolant_followed': self.orbit_interpolant_followed,
'cloud_in_dark': self.cloud_in_dark,
'cloud_in_echo': self.cloud_in_echo,
'explosion_damage': self.explosion_damage.to_json(),
'turn_sound': self.turn_sound,
'death_sound': self.death_sound,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_is_orbitable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hover_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cloud_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cloud_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_cloud_steam(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_cloud_steam_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_orbit_interpolant_followed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_cloud_in_dark(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_cloud_in_echo(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explosion_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_turn_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_death_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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x826bec80: ('is_orbitable', _decode_is_orbitable),
0x845ef489: ('hover_speed', _decode_hover_speed),
0x670b9a1f: ('cloud_effect', _decode_cloud_effect),
0xe8619082: ('cloud_damage', _decode_cloud_damage),
0x1aa418f4: ('cloud_steam', _decode_cloud_steam),
0xc9a55479: ('cloud_steam_alpha', _decode_cloud_steam_alpha),
0x98647f20: ('orbit_interpolant_followed', _decode_orbit_interpolant_followed),
0x8a30112f: ('cloud_in_dark', _decode_cloud_in_dark),
0x86c887a5: ('cloud_in_echo', _decode_cloud_in_echo),
0xdeff74ea: ('explosion_damage', _decode_explosion_damage),
0xc4c39403: ('turn_sound', _decode_turn_sound),
0xc7c3f610: ('death_sound', _decode_death_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Puffer.py | 0.527317 | 0.262765 | Puffer.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.MetroidHopperData import MetroidHopperData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class MetroidHopper(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
metroid_hopper_data: MetroidHopperData = dataclasses.field(default_factory=MetroidHopperData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'MHOP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MetroidHopper.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'\xd9H\x8f\xbd') # 0xd9488fbd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.metroid_hopper_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']),
actor_information=ActorParameters.from_json(data['actor_information']),
metroid_hopper_data=MetroidHopperData.from_json(data['metroid_hopper_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'metroid_hopper_data': self.metroid_hopper_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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_metroid_hopper_data(data: typing.BinaryIO, property_size: int):
return MetroidHopperData.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xd9488fbd: ('metroid_hopper_data', _decode_metroid_hopper_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MetroidHopper.py | 0.608361 | 0.347316 | MetroidHopper.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AudioOccluder(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
volume_attenuation: float = dataclasses.field(default=1.0)
unknown: int = dataclasses.field(default=32000)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AOCL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfe\x89\xb6\xe4') # 0xfe89b6e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_attenuation))
data.write(b'\xfa{VP') # 0xfa7b5650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
volume_attenuation=data['volume_attenuation'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'volume_attenuation': self.volume_attenuation,
'unknown': self.unknown,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_volume_attenuation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfe89b6e4: ('volume_attenuation', _decode_volume_attenuation),
0xfa7b5650: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AudioOccluder.py | 0.645455 | 0.349006 | AudioOccluder.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class Generator(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
min_number_objects_to_generate: int = dataclasses.field(default=1)
max_number_objects_to_generate: int = dataclasses.field(default=1)
unique_objects: bool = dataclasses.field(default=False)
unique_locations: bool = dataclasses.field(default=False)
keep_orientation: bool = dataclasses.field(default=False)
use_originator_transform: bool = dataclasses.field(default=False)
offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
offset_is_local_space: bool = dataclasses.field(default=False)
random_scale_min: float = dataclasses.field(default=1.0)
random_scale_max: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GENR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'k\xddV\xd6') # 0x6bdd56d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.min_number_objects_to_generate))
data.write(b'\x84_H\xac') # 0x845f48ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_number_objects_to_generate))
data.write(b'\xe4\xd2G\xe4') # 0xe4d247e4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unique_objects))
data.write(b'\x88\x97\x8eI') # 0x88978e49
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unique_locations))
data.write(b'\x1e\xb8\xe2T') # 0x1eb8e254
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.keep_orientation))
data.write(b'\x03Z^\x10') # 0x35a5e10
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_originator_transform))
data.write(b'FGpd') # 0x46477064
data.write(b'\x00\x0c') # size
self.offset.to_stream(data)
data.write(b'r\xbb\xe7\xa6') # 0x72bbe7a6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.offset_is_local_space))
data.write(b'\xc3\x86\x1bd') # 0xc3861b64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_scale_min))
data.write(b'%\xe6\xb4\x85') # 0x25e6b485
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_scale_max))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
min_number_objects_to_generate=data['min_number_objects_to_generate'],
max_number_objects_to_generate=data['max_number_objects_to_generate'],
unique_objects=data['unique_objects'],
unique_locations=data['unique_locations'],
keep_orientation=data['keep_orientation'],
use_originator_transform=data['use_originator_transform'],
offset=Vector.from_json(data['offset']),
offset_is_local_space=data['offset_is_local_space'],
random_scale_min=data['random_scale_min'],
random_scale_max=data['random_scale_max'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'min_number_objects_to_generate': self.min_number_objects_to_generate,
'max_number_objects_to_generate': self.max_number_objects_to_generate,
'unique_objects': self.unique_objects,
'unique_locations': self.unique_locations,
'keep_orientation': self.keep_orientation,
'use_originator_transform': self.use_originator_transform,
'offset': self.offset.to_json(),
'offset_is_local_space': self.offset_is_local_space,
'random_scale_min': self.random_scale_min,
'random_scale_max': self.random_scale_max,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_min_number_objects_to_generate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_number_objects_to_generate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unique_objects(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unique_locations(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_keep_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_originator_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_offset_is_local_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_random_scale_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_scale_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6bdd56d6: ('min_number_objects_to_generate', _decode_min_number_objects_to_generate),
0x845f48ac: ('max_number_objects_to_generate', _decode_max_number_objects_to_generate),
0xe4d247e4: ('unique_objects', _decode_unique_objects),
0x88978e49: ('unique_locations', _decode_unique_locations),
0x1eb8e254: ('keep_orientation', _decode_keep_orientation),
0x35a5e10: ('use_originator_transform', _decode_use_originator_transform),
0x46477064: ('offset', _decode_offset),
0x72bbe7a6: ('offset_is_local_space', _decode_offset_is_local_space),
0xc3861b64: ('random_scale_min', _decode_random_scale_min),
0x25e6b485: ('random_scale_max', _decode_random_scale_max),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Generator.py | 0.587943 | 0.363732 | Generator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.TriggerInfo import TriggerInfo
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class BallTrigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
attraction_force: float = dataclasses.field(default=20.0)
attraction_angle: float = dataclasses.field(default=60.0)
attraction_distance: float = dataclasses.field(default=20.0)
attraction_direction: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=0.0, z=0.0))
no_ball_movement: bool = dataclasses.field(default=False)
bounds_size_multiplier: float = dataclasses.field(default=1.0)
fix_position_on_activate: bool = dataclasses.field(default=False)
trigger_properties: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'BALT'
@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'\xb6\x1b\x11I') # 0xb61b1149
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attraction_force))
data.write(b'\x81\xafQ\xd5') # 0x81af51d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attraction_angle))
data.write(b'\xbb8\xd0w') # 0xbb38d077
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attraction_distance))
data.write(b'\xeaQ\x1d\x83') # 0xea511d83
data.write(b'\x00\x0c') # size
self.attraction_direction.to_stream(data)
data.write(b'\xb6\x13\xf4\xe4') # 0xb613f4e4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_ball_movement))
data.write(b"'fcj") # 0x2766636a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounds_size_multiplier))
data.write(b'f\xa4>\xef') # 0x66a43eef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.fix_position_on_activate))
data.write(b'\xbb\xfe\xe9>') # 0xbbfee93e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
attraction_force=data['attraction_force'],
attraction_angle=data['attraction_angle'],
attraction_distance=data['attraction_distance'],
attraction_direction=Vector.from_json(data['attraction_direction']),
no_ball_movement=data['no_ball_movement'],
bounds_size_multiplier=data['bounds_size_multiplier'],
fix_position_on_activate=data['fix_position_on_activate'],
trigger_properties=TriggerInfo.from_json(data['trigger_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'attraction_force': self.attraction_force,
'attraction_angle': self.attraction_angle,
'attraction_distance': self.attraction_distance,
'attraction_direction': self.attraction_direction.to_json(),
'no_ball_movement': self.no_ball_movement,
'bounds_size_multiplier': self.bounds_size_multiplier,
'fix_position_on_activate': self.fix_position_on_activate,
'trigger_properties': self.trigger_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_attraction_force(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attraction_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attraction_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attraction_direction(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_no_ball_movement(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_bounds_size_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fix_position_on_activate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_trigger_properties(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb61b1149: ('attraction_force', _decode_attraction_force),
0x81af51d5: ('attraction_angle', _decode_attraction_angle),
0xbb38d077: ('attraction_distance', _decode_attraction_distance),
0xea511d83: ('attraction_direction', _decode_attraction_direction),
0xb613f4e4: ('no_ball_movement', _decode_no_ball_movement),
0x2766636a: ('bounds_size_multiplier', _decode_bounds_size_multiplier),
0x66a43eef: ('fix_position_on_activate', _decode_fix_position_on_activate),
0xbbfee93e: ('trigger_properties', _decode_trigger_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/BallTrigger.py | 0.652131 | 0.310851 | BallTrigger.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.ReptilicusHunterData import ReptilicusHunterData
@dataclasses.dataclass()
class ReptilicusHunter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
reptilicus_hunter_data: ReptilicusHunterData = dataclasses.field(default_factory=ReptilicusHunterData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'REPH'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ReptilicusHunter.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0})
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';p\x85\xad') # 0x3b7085ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.reptilicus_hunter_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']),
actor_information=ActorParameters.from_json(data['actor_information']),
reptilicus_hunter_data=ReptilicusHunterData.from_json(data['reptilicus_hunter_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'reptilicus_hunter_data': self.reptilicus_hunter_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={'turn_speed': 360.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_reptilicus_hunter_data(data: typing.BinaryIO, property_size: int):
return ReptilicusHunterData.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0x3b7085ad: ('reptilicus_hunter_data', _decode_reptilicus_hunter_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ReptilicusHunter.py | 0.601594 | 0.335814 | ReptilicusHunter.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AreaStreamedAudioState(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
area_state: enums.AreaState = dataclasses.field(default=enums.AreaState.Unknown1)
auto_set: bool = dataclasses.field(default=False)
global_: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'ASAS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xe7\xd8\xd8#') # 0xe7d8d823
data.write(b'\x00\x04') # size
self.area_state.to_stream(data)
data.write(b'\x05\xc9$l') # 0x5c9246c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_set))
data.write(b'$\t\xb9\x06') # 0x2409b906
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.global_))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
area_state=enums.AreaState.from_json(data['area_state']),
auto_set=data['auto_set'],
global_=data['global_'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'area_state': self.area_state.to_json(),
'auto_set': self.auto_set,
'global_': self.global_,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_area_state(data: typing.BinaryIO, property_size: int):
return enums.AreaState.from_stream(data)
def _decode_auto_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_global_(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe7d8d823: ('area_state', _decode_area_state),
0x5c9246c: ('auto_set', _decode_auto_set),
0x2409b906: ('global_', _decode_global_),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AreaStreamedAudioState.py | 0.608245 | 0.335215 | AreaStreamedAudioState.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ConditionalTest import ConditionalTest
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ConditionalRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger_on_first_think: bool = dataclasses.field(default=False)
multiplayer_mask_and_negate: int = dataclasses.field(default=7) # Choice
conditional1: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional2: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional3: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional4: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'D\xdb\x8a\xf2') # 0x44db8af2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.trigger_on_first_think))
data.write(b',\xc5Nw') # 0x2cc54e77
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.multiplayer_mask_and_negate))
data.write(b'\xce\xc1i2') # 0xcec16932
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\t\xdd\xc0') # 0xe709ddc0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional2.to_stream(data, default_override={'boolean': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'IaLQ') # 0x49614c51
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional3.to_stream(data, default_override={'boolean': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\x98\xb4$') # 0xb498b424
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional4.to_stream(data, default_override={'boolean': 0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
trigger_on_first_think=data['trigger_on_first_think'],
multiplayer_mask_and_negate=data['multiplayer_mask_and_negate'],
conditional1=ConditionalTest.from_json(data['conditional1']),
conditional2=ConditionalTest.from_json(data['conditional2']),
conditional3=ConditionalTest.from_json(data['conditional3']),
conditional4=ConditionalTest.from_json(data['conditional4']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger_on_first_think': self.trigger_on_first_think,
'multiplayer_mask_and_negate': self.multiplayer_mask_and_negate,
'conditional1': self.conditional1.to_json(),
'conditional2': self.conditional2.to_json(),
'conditional3': self.conditional3.to_json(),
'conditional4': self.conditional4.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger_on_first_think(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_multiplayer_mask_and_negate(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_conditional1(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size)
def _decode_conditional2(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': 0})
def _decode_conditional3(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': 0})
def _decode_conditional4(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': 0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44db8af2: ('trigger_on_first_think', _decode_trigger_on_first_think),
0x2cc54e77: ('multiplayer_mask_and_negate', _decode_multiplayer_mask_and_negate),
0xcec16932: ('conditional1', _decode_conditional1),
0xe709ddc0: ('conditional2', _decode_conditional2),
0x49614c51: ('conditional3', _decode_conditional3),
0xb498b424: ('conditional4', _decode_conditional4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ConditionalRelay.py | 0.617628 | 0.323621 | ConditionalRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Color import Color
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class FogOverlay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
full_alpha: float = dataclasses.field(default=1.0)
fade_down_time: float = dataclasses.field(default=1.0)
fade_up_time: float = dataclasses.field(default=1.0)
start_faded_out: bool = dataclasses.field(default=False)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
ambient_radius_x: float = dataclasses.field(default=0.5)
ambient_radius_y: float = dataclasses.field(default=0.20000000298023224)
ambient_speed: float = dataclasses.field(default=0.10000000149011612)
ambient_speed_target: float = dataclasses.field(default=0.10000000149011612)
unknown_0x6a111b96: float = dataclasses.field(default=1.0)
unknown_0xff226ea3: float = dataclasses.field(default=1.0)
unknown_0x2190ab0a: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x9f19f0af: float = dataclasses.field(default=0.10000000149011612)
unknown_0x90c10fe7: float = dataclasses.field(default=1.0)
unknown_0xd8daff1d: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOGO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x10') # 16 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'T{(\xd5') # 0x547b28d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_alpha))
data.write(b'\xf9w\xcb5') # 0xf977cb35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_down_time))
data.write(b'\r!\xd3H') # 0xd21d348
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_up_time))
data.write(b'\xeb%\n\x0b') # 0xeb250a0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_faded_out))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\x1b\x90F\xd6') # 0x1b9046d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_radius_x))
data.write(b'\xd0\xcc\x95s') # 0xd0cc9573
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_radius_y))
data.write(b'\xf7k\xcb\xdd') # 0xf76bcbdd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_speed))
data.write(b',Lg\x85') # 0x2c4c6785
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_speed_target))
data.write(b'j\x11\x1b\x96') # 0x6a111b96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6a111b96))
data.write(b'\xff"n\xa3') # 0xff226ea3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xff226ea3))
data.write(b'!\x90\xab\n') # 0x2190ab0a
data.write(b'\x00\x0c') # size
self.unknown_0x2190ab0a.to_stream(data)
data.write(b'\x9f\x19\xf0\xaf') # 0x9f19f0af
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9f19f0af))
data.write(b'\x90\xc1\x0f\xe7') # 0x90c10fe7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x90c10fe7))
data.write(b'\xd8\xda\xff\x1d') # 0xd8daff1d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd8daff1d))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
full_alpha=data['full_alpha'],
fade_down_time=data['fade_down_time'],
fade_up_time=data['fade_up_time'],
start_faded_out=data['start_faded_out'],
color=Color.from_json(data['color']),
ambient_radius_x=data['ambient_radius_x'],
ambient_radius_y=data['ambient_radius_y'],
ambient_speed=data['ambient_speed'],
ambient_speed_target=data['ambient_speed_target'],
unknown_0x6a111b96=data['unknown_0x6a111b96'],
unknown_0xff226ea3=data['unknown_0xff226ea3'],
unknown_0x2190ab0a=Vector.from_json(data['unknown_0x2190ab0a']),
unknown_0x9f19f0af=data['unknown_0x9f19f0af'],
unknown_0x90c10fe7=data['unknown_0x90c10fe7'],
unknown_0xd8daff1d=data['unknown_0xd8daff1d'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'full_alpha': self.full_alpha,
'fade_down_time': self.fade_down_time,
'fade_up_time': self.fade_up_time,
'start_faded_out': self.start_faded_out,
'color': self.color.to_json(),
'ambient_radius_x': self.ambient_radius_x,
'ambient_radius_y': self.ambient_radius_y,
'ambient_speed': self.ambient_speed,
'ambient_speed_target': self.ambient_speed_target,
'unknown_0x6a111b96': self.unknown_0x6a111b96,
'unknown_0xff226ea3': self.unknown_0xff226ea3,
'unknown_0x2190ab0a': self.unknown_0x2190ab0a.to_json(),
'unknown_0x9f19f0af': self.unknown_0x9f19f0af,
'unknown_0x90c10fe7': self.unknown_0x90c10fe7,
'unknown_0xd8daff1d': self.unknown_0xd8daff1d,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_full_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_down_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_up_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_faded_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_ambient_radius_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_radius_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_speed_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6a111b96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xff226ea3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2190ab0a(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x9f19f0af(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x90c10fe7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd8daff1d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x547b28d5: ('full_alpha', _decode_full_alpha),
0xf977cb35: ('fade_down_time', _decode_fade_down_time),
0xd21d348: ('fade_up_time', _decode_fade_up_time),
0xeb250a0b: ('start_faded_out', _decode_start_faded_out),
0x37c7d09d: ('color', _decode_color),
0x1b9046d6: ('ambient_radius_x', _decode_ambient_radius_x),
0xd0cc9573: ('ambient_radius_y', _decode_ambient_radius_y),
0xf76bcbdd: ('ambient_speed', _decode_ambient_speed),
0x2c4c6785: ('ambient_speed_target', _decode_ambient_speed_target),
0x6a111b96: ('unknown_0x6a111b96', _decode_unknown_0x6a111b96),
0xff226ea3: ('unknown_0xff226ea3', _decode_unknown_0xff226ea3),
0x2190ab0a: ('unknown_0x2190ab0a', _decode_unknown_0x2190ab0a),
0x9f19f0af: ('unknown_0x9f19f0af', _decode_unknown_0x9f19f0af),
0x90c10fe7: ('unknown_0x90c10fe7', _decode_unknown_0x90c10fe7),
0xd8daff1d: ('unknown_0xd8daff1d', _decode_unknown_0xd8daff1d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FogOverlay.py | 0.571886 | 0.298923 | FogOverlay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.ScanBeamInfo import ScanBeamInfo
@dataclasses.dataclass()
class ScanBeam(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
scan_beam_info: ScanBeamInfo = dataclasses.field(default_factory=ScanBeamInfo)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SBEM'
@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'y\xf0dY') # 0x79f06459
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_beam_info.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']),
scan_beam_info=ScanBeamInfo.from_json(data['scan_beam_info']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'scan_beam_info': self.scan_beam_info.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_scan_beam_info(data: typing.BinaryIO, property_size: int):
return ScanBeamInfo.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),
0x79f06459: ('scan_beam_info', _decode_scan_beam_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ScanBeam.py | 0.604516 | 0.374562 | ScanBeam.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SpiderBallAttractionSurface(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'BALS'
@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/corruption/objects/SpiderBallAttractionSurface.py | 0.58261 | 0.347759 | SpiderBallAttractionSurface.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.BerserkerData import BerserkerData
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct21 import UnknownStruct21
@dataclasses.dataclass()
class Berserker(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned_info: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
berserker_info: BerserkerData = dataclasses.field(default_factory=BerserkerData)
berserker_info_hard: BerserkerData = dataclasses.field(default_factory=BerserkerData)
berserker_info_elite: BerserkerData = dataclasses.field(default_factory=BerserkerData)
unknown_struct21: UnknownStruct21 = dataclasses.field(default_factory=UnknownStruct21)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'BSKR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Berserker.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\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\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'C\xbb\xb1\xdd') # 0x43bbb1dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_info.to_stream(data, default_override={'damage_wait_time': 3.0, 'step_up_height': 1.0, 'creature_size': 2, 'turn_speed': 180.0, 'detection_range': 50.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'average_attack_time': 1.0, 'attack_time_variation': 0.5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'T\xf9\xff\xa5') # 0x54f9ffa5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.berserker_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-\x8d\xc0\xaf') # 0x2d8dc0af
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.berserker_info_hard.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe1\x0c\xe8(') # 0xe10ce828
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.berserker_info_elite.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{\x8cH\xc7') # 0x7b8c48c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct21.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_info=PatternedAITypedef.from_json(data['patterned_info']),
berserker_info=BerserkerData.from_json(data['berserker_info']),
berserker_info_hard=BerserkerData.from_json(data['berserker_info_hard']),
berserker_info_elite=BerserkerData.from_json(data['berserker_info_elite']),
unknown_struct21=UnknownStruct21.from_json(data['unknown_struct21']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'patterned_info': self.patterned_info.to_json(),
'berserker_info': self.berserker_info.to_json(),
'berserker_info_hard': self.berserker_info_hard.to_json(),
'berserker_info_elite': self.berserker_info_elite.to_json(),
'unknown_struct21': self.unknown_struct21.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_info(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'damage_wait_time': 3.0, 'step_up_height': 1.0, 'creature_size': 2, 'turn_speed': 180.0, 'detection_range': 50.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'average_attack_time': 1.0, 'attack_time_variation': 0.5})
def _decode_berserker_info(data: typing.BinaryIO, property_size: int):
return BerserkerData.from_stream(data, property_size)
def _decode_berserker_info_hard(data: typing.BinaryIO, property_size: int):
return BerserkerData.from_stream(data, property_size)
def _decode_berserker_info_elite(data: typing.BinaryIO, property_size: int):
return BerserkerData.from_stream(data, property_size)
def _decode_unknown_struct21(data: typing.BinaryIO, property_size: int):
return UnknownStruct21.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),
0x43bbb1dd: ('patterned_info', _decode_patterned_info),
0x54f9ffa5: ('berserker_info', _decode_berserker_info),
0x2d8dc0af: ('berserker_info_hard', _decode_berserker_info_hard),
0xe10ce828: ('berserker_info_elite', _decode_berserker_info_elite),
0x7b8c48c7: ('unknown_struct21', _decode_unknown_struct21),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Berserker.py | 0.571886 | 0.365598 | Berserker.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class PhazonTentacle(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PTNT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PhazonTentacle.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhazonTentacle.py | 0.68437 | 0.344664 | PhazonTentacle.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.SpacePirateWeaponData import SpacePirateWeaponData
from retro_data_structures.properties.corruption.archetypes.SwarmBasicsData import SwarmBasicsData
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class PlantScarabSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
swarm_basics_data: SwarmBasicsData = dataclasses.field(default_factory=SwarmBasicsData)
unknown_0xe44c130c: int = dataclasses.field(default=0)
unknown_0x47177c43: int = dataclasses.field(default=0)
max_attack_angle: float = dataclasses.field(default=30.0)
into_attack_speed: float = dataclasses.field(default=1.0)
attack_speed: float = dataclasses.field(default=1.0)
grenade_data: SpacePirateWeaponData = dataclasses.field(default_factory=SpacePirateWeaponData)
grenade_launch_speed: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PSSM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa2D\xc9\xd8') # 0xa244c9d8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'L\xfcF\xfe') # 0x4cfc46fe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swarm_basics_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe4L\x13\x0c') # 0xe44c130c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe44c130c))
data.write(b'G\x17|C') # 0x47177c43
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x47177c43))
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'\xcav\x1d\xcd') # 0xca761dcd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.into_attack_speed))
data.write(b'l\n+\xc8') # 0x6c0a2bc8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_speed))
data.write(b'\xc3\xb6\x10;') # 0xc3b6103b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grenade_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\x96,\x9b') # 0x16962c9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_launch_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']),
actor_information=ActorParameters.from_json(data['actor_information']),
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
active=data['active'],
swarm_basics_data=SwarmBasicsData.from_json(data['swarm_basics_data']),
unknown_0xe44c130c=data['unknown_0xe44c130c'],
unknown_0x47177c43=data['unknown_0x47177c43'],
max_attack_angle=data['max_attack_angle'],
into_attack_speed=data['into_attack_speed'],
attack_speed=data['attack_speed'],
grenade_data=SpacePirateWeaponData.from_json(data['grenade_data']),
grenade_launch_speed=data['grenade_launch_speed'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'character_animation_information': self.character_animation_information.to_json(),
'active': self.active,
'swarm_basics_data': self.swarm_basics_data.to_json(),
'unknown_0xe44c130c': self.unknown_0xe44c130c,
'unknown_0x47177c43': self.unknown_0x47177c43,
'max_attack_angle': self.max_attack_angle,
'into_attack_speed': self.into_attack_speed,
'attack_speed': self.attack_speed,
'grenade_data': self.grenade_data.to_json(),
'grenade_launch_speed': self.grenade_launch_speed,
}
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_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_swarm_basics_data(data: typing.BinaryIO, property_size: int):
return SwarmBasicsData.from_stream(data, property_size)
def _decode_unknown_0xe44c130c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x47177c43(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', 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_into_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_data(data: typing.BinaryIO, property_size: int):
return SpacePirateWeaponData.from_stream(data, property_size)
def _decode_grenade_launch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0xc6bb2f45: ('active', _decode_active),
0x4cfc46fe: ('swarm_basics_data', _decode_swarm_basics_data),
0xe44c130c: ('unknown_0xe44c130c', _decode_unknown_0xe44c130c),
0x47177c43: ('unknown_0x47177c43', _decode_unknown_0x47177c43),
0xf11f7384: ('max_attack_angle', _decode_max_attack_angle),
0xca761dcd: ('into_attack_speed', _decode_into_attack_speed),
0x6c0a2bc8: ('attack_speed', _decode_attack_speed),
0xc3b6103b: ('grenade_data', _decode_grenade_data),
0x16962c9b: ('grenade_launch_speed', _decode_grenade_launch_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PlantScarabSwarm.py | 0.559651 | 0.282409 | PlantScarabSwarm.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class PlayerGravityScalar(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: float = dataclasses.field(default=0.41999998688697815)
morph_ball_gravity_scale: float = dataclasses.field(default=0.6000000238418579)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PGVS'
@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'Y\xed+\x0c') # 0x59ed2b0c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x9b\x8ePc') # 0x9b8e5063
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.morph_ball_gravity_scale))
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'],
morph_ball_gravity_scale=data['morph_ball_gravity_scale'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown,
'morph_ball_gravity_scale': self.morph_ball_gravity_scale,
}
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('>f', data.read(4))[0]
def _decode_morph_ball_gravity_scale(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),
0x59ed2b0c: ('unknown', _decode_unknown),
0x9b8e5063: ('morph_ball_gravity_scale', _decode_morph_ball_gravity_scale),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PlayerGravityScalar.py | 0.634996 | 0.341445 | PlayerGravityScalar.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.EyePodData import EyePodData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.WallCrawlerData import WallCrawlerData
@dataclasses.dataclass()
class EyePod(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
wall_crawler_properties: WallCrawlerData = dataclasses.field(default_factory=WallCrawlerData)
eye_pod_properties: EyePodData = dataclasses.field(default_factory=EyePodData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'EYEP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_EyePod.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'\xb7\x18\xb81') # 0xb718b831
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.wall_crawler_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x92\x14\xa5\x18') # 0x9214a518
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.eye_pod_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={'step_up_height': 1.0, 'leash_radius': 100.0})
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)
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']),
wall_crawler_properties=WallCrawlerData.from_json(data['wall_crawler_properties']),
eye_pod_properties=EyePodData.from_json(data['eye_pod_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'wall_crawler_properties': self.wall_crawler_properties.to_json(),
'eye_pod_properties': self.eye_pod_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_wall_crawler_properties(data: typing.BinaryIO, property_size: int):
return WallCrawlerData.from_stream(data, property_size)
def _decode_eye_pod_properties(data: typing.BinaryIO, property_size: int):
return EyePodData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'step_up_height': 1.0, 'leash_radius': 100.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb718b831: ('wall_crawler_properties', _decode_wall_crawler_properties),
0x9214a518: ('eye_pod_properties', _decode_eye_pod_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/EyePod.py | 0.628179 | 0.313151 | EyePod.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct51 import UnknownStruct51
@dataclasses.dataclass()
class PhazonPuffer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct51: UnknownStruct51 = dataclasses.field(default_factory=UnknownStruct51)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PHPF'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PhazonPuffer.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'\x1b\xe8\xb2\xdb') # 0x1be8b2db
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct51.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']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct51=UnknownStruct51.from_json(data['unknown_struct51']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct51': self.unknown_struct51.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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct51(data: typing.BinaryIO, property_size: int):
return UnknownStruct51.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x1be8b2db: ('unknown_struct51', _decode_unknown_struct51),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhazonPuffer.py | 0.634204 | 0.324369 | PhazonPuffer.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIWaypoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
speed: float = dataclasses.field(default=1.0)
pause: float = dataclasses.field(default=0.0)
unknown_0xc6705a00: int = dataclasses.field(default=0)
locator_index: int = dataclasses.field(default=0)
unknown_0x166979d4: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIWP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'\x80\xf7\xe6\x05') # 0x80f7e605
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause))
data.write(b'\xc6pZ\x00') # 0xc6705a00
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc6705a00))
data.write(b'\xa7\x90\xc6\xa9') # 0xa790c6a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.locator_index))
data.write(b'\x16iy\xd4') # 0x166979d4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x166979d4))
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']),
speed=data['speed'],
pause=data['pause'],
unknown_0xc6705a00=data['unknown_0xc6705a00'],
locator_index=data['locator_index'],
unknown_0x166979d4=data['unknown_0x166979d4'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'speed': self.speed,
'pause': self.pause,
'unknown_0xc6705a00': self.unknown_0xc6705a00,
'locator_index': self.locator_index,
'unknown_0x166979d4': self.unknown_0x166979d4,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pause(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc6705a00(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_locator_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x166979d4(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),
0x6392404e: ('speed', _decode_speed),
0x80f7e605: ('pause', _decode_pause),
0xc6705a00: ('unknown_0xc6705a00', _decode_unknown_0xc6705a00),
0xa790c6a9: ('locator_index', _decode_locator_index),
0x166979d4: ('unknown_0x166979d4', _decode_unknown_0x166979d4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AIWaypoint.py | 0.591605 | 0.319201 | AIWaypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.UnknownStruct22 import UnknownStruct22
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class ContextActionButtonPressing(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct22: UnknownStruct22 = dataclasses.field(default_factory=UnknownStruct22)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'CABP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptContextActionButtonPressing.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'9\x070\x0e') # 0x3907300e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct22.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@D\xd9\xe5') # 0x4044d9e5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_struct22=UnknownStruct22.from_json(data['unknown_struct22']),
animation_information=AnimationParameters.from_json(data['animation_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct22': self.unknown_struct22.to_json(),
'animation_information': self.animation_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct22(data: typing.BinaryIO, property_size: int):
return UnknownStruct22.from_stream(data, property_size)
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3907300e: ('unknown_struct22', _decode_unknown_struct22),
0x4044d9e5: ('animation_information', _decode_animation_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ContextActionButtonPressing.py | 0.674587 | 0.320582 | ContextActionButtonPressing.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.MetroidHatcherData import MetroidHatcherData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class MetroidHatcher(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
patterned_ai_0x5c056cef: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
patterned_ai_0x8be7ecb7: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
metroid_hatcher_data_0x42e95705: MetroidHatcherData = dataclasses.field(default_factory=MetroidHatcherData)
metroid_hatcher_data_0x266b7d6b: MetroidHatcherData = dataclasses.field(default_factory=MetroidHatcherData)
metroid_hatcher_data_0xf189fd33: MetroidHatcherData = dataclasses.field(default_factory=MetroidHatcherData)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'MHAT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MetroidHatcher.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\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 1000.0, 'collision_radius': 3.0, 'collision_height': 9.0, 'collision_offset': Vector(x=0.0, y=0.0, z=-1.7999999523162842), 'step_up_height': 1.0, 'creature_size': 2, 'leash_radius': 100.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\\x05l\xef') # 0x5c056cef
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x5c056cef.to_stream(data, default_override={'mass': 1000.0, 'collision_radius': 3.0, 'collision_height': 9.0, 'collision_offset': Vector(x=0.0, y=0.0, z=-1.7999999523162842), 'step_up_height': 1.0, 'creature_size': 2, 'leash_radius': 100.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xe7\xec\xb7') # 0x8be7ecb7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x8be7ecb7.to_stream(data, default_override={'mass': 1000.0, 'collision_radius': 3.0, 'collision_height': 9.0, 'collision_offset': Vector(x=0.0, y=0.0, z=-1.7999999523162842), 'step_up_height': 1.0, 'creature_size': 2, 'leash_radius': 100.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'B\xe9W\x05') # 0x42e95705
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.metroid_hatcher_data_0x42e95705.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'&k}k') # 0x266b7d6b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.metroid_hatcher_data_0x266b7d6b.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1\x89\xfd3') # 0xf189fd33
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.metroid_hatcher_data_0xf189fd33.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)
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']),
patterned_ai_0x5c056cef=PatternedAITypedef.from_json(data['patterned_ai_0x5c056cef']),
patterned_ai_0x8be7ecb7=PatternedAITypedef.from_json(data['patterned_ai_0x8be7ecb7']),
metroid_hatcher_data_0x42e95705=MetroidHatcherData.from_json(data['metroid_hatcher_data_0x42e95705']),
metroid_hatcher_data_0x266b7d6b=MetroidHatcherData.from_json(data['metroid_hatcher_data_0x266b7d6b']),
metroid_hatcher_data_0xf189fd33=MetroidHatcherData.from_json(data['metroid_hatcher_data_0xf189fd33']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'patterned_ai_0x5c056cef': self.patterned_ai_0x5c056cef.to_json(),
'patterned_ai_0x8be7ecb7': self.patterned_ai_0x8be7ecb7.to_json(),
'metroid_hatcher_data_0x42e95705': self.metroid_hatcher_data_0x42e95705.to_json(),
'metroid_hatcher_data_0x266b7d6b': self.metroid_hatcher_data_0x266b7d6b.to_json(),
'metroid_hatcher_data_0xf189fd33': self.metroid_hatcher_data_0xf189fd33.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 1000.0, 'collision_radius': 3.0, 'collision_height': 9.0, 'collision_offset': Vector(x=0.0, y=0.0, z=-1.7999999523162842), 'step_up_height': 1.0, 'creature_size': 2, 'leash_radius': 100.0})
def _decode_patterned_ai_0x5c056cef(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 1000.0, 'collision_radius': 3.0, 'collision_height': 9.0, 'collision_offset': Vector(x=0.0, y=0.0, z=-1.7999999523162842), 'step_up_height': 1.0, 'creature_size': 2, 'leash_radius': 100.0})
def _decode_patterned_ai_0x8be7ecb7(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 1000.0, 'collision_radius': 3.0, 'collision_height': 9.0, 'collision_offset': Vector(x=0.0, y=0.0, z=-1.7999999523162842), 'step_up_height': 1.0, 'creature_size': 2, 'leash_radius': 100.0})
def _decode_metroid_hatcher_data_0x42e95705(data: typing.BinaryIO, property_size: int):
return MetroidHatcherData.from_stream(data, property_size)
def _decode_metroid_hatcher_data_0x266b7d6b(data: typing.BinaryIO, property_size: int):
return MetroidHatcherData.from_stream(data, property_size)
def _decode_metroid_hatcher_data_0xf189fd33(data: typing.BinaryIO, property_size: int):
return MetroidHatcherData.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x5c056cef: ('patterned_ai_0x5c056cef', _decode_patterned_ai_0x5c056cef),
0x8be7ecb7: ('patterned_ai_0x8be7ecb7', _decode_patterned_ai_0x8be7ecb7),
0x42e95705: ('metroid_hatcher_data_0x42e95705', _decode_metroid_hatcher_data_0x42e95705),
0x266b7d6b: ('metroid_hatcher_data_0x266b7d6b', _decode_metroid_hatcher_data_0x266b7d6b),
0xf189fd33: ('metroid_hatcher_data_0xf189fd33', _decode_metroid_hatcher_data_0xf189fd33),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MetroidHatcher.py | 0.533884 | 0.329931 | MetroidHatcher.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class ContextSensitiveAction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation: int = dataclasses.field(default=0)
rotation_blend_mode: enums.RotationBlendMode = dataclasses.field(default=enums.RotationBlendMode.Unknown1)
blend: Spline = dataclasses.field(default_factory=Spline)
mode: enums.Mode = dataclasses.field(default=enums.Mode.Unknown1)
controller_type: enums.ControllerType = dataclasses.field(default=enums.ControllerType.Unknown1)
unknown: float = dataclasses.field(default=1.0)
hide_aiming_cursor: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'CSAC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptContextSensitiveAction.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\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\xcd\xb1\x1c') # 0xaacdb11c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation))
data.write(b'\xb0h\xf4\x0b') # 0xb068f40b
data.write(b'\x00\x04') # size
self.rotation_blend_mode.to_stream(data)
data.write(b'\xf9\xdf\xe0\x1d') # 0xf9dfe01d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.blend.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8\xf6\x0f\x9a') # 0xb8f60f9a
data.write(b'\x00\x04') # size
self.mode.to_stream(data)
data.write(b'\x89r\xa8o') # 0x8972a86f
data.write(b'\x00\x04') # size
self.controller_type.to_stream(data)
data.write(b'\xbf\n\xdf@') # 0xbf0adf40
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\xca@\x16\xa1') # 0xca4016a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hide_aiming_cursor))
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']),
animation=data['animation'],
rotation_blend_mode=enums.RotationBlendMode.from_json(data['rotation_blend_mode']),
blend=Spline.from_json(data['blend']),
mode=enums.Mode.from_json(data['mode']),
controller_type=enums.ControllerType.from_json(data['controller_type']),
unknown=data['unknown'],
hide_aiming_cursor=data['hide_aiming_cursor'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation': self.animation,
'rotation_blend_mode': self.rotation_blend_mode.to_json(),
'blend': self.blend.to_json(),
'mode': self.mode.to_json(),
'controller_type': self.controller_type.to_json(),
'unknown': self.unknown,
'hide_aiming_cursor': self.hide_aiming_cursor,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_rotation_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.RotationBlendMode.from_stream(data)
def _decode_blend(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_mode(data: typing.BinaryIO, property_size: int):
return enums.Mode.from_stream(data)
def _decode_controller_type(data: typing.BinaryIO, property_size: int):
return enums.ControllerType.from_stream(data)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hide_aiming_cursor(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),
0xaacdb11c: ('animation', _decode_animation),
0xb068f40b: ('rotation_blend_mode', _decode_rotation_blend_mode),
0xf9dfe01d: ('blend', _decode_blend),
0xb8f60f9a: ('mode', _decode_mode),
0x8972a86f: ('controller_type', _decode_controller_type),
0xbf0adf40: ('unknown', _decode_unknown),
0xca4016a1: ('hide_aiming_cursor', _decode_hide_aiming_cursor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ContextSensitiveAction.py | 0.635675 | 0.358634 | ContextSensitiveAction.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class WorldLightFader(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
target_light: float = dataclasses.field(default=1.0)
target_light_rate: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WLIT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfbg\xa2k') # 0xfb67a26b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_light))
data.write(b'#M\xceR') # 0x234dce52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_light_rate))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
target_light=data['target_light'],
target_light_rate=data['target_light_rate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'target_light': self.target_light,
'target_light_rate': self.target_light_rate,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_target_light(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_light_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfb67a26b: ('target_light', _decode_target_light),
0x234dce52: ('target_light_rate', _decode_target_light_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WorldLightFader.py | 0.657428 | 0.361756 | WorldLightFader.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class RumbleEffect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
radius: float = dataclasses.field(default=20.0)
effect: int = dataclasses.field(default=0) # Choice
flags_rumble: int = dataclasses.field(default=0) # Flagset
unknown: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RUMB'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
num_properties_written = 4
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\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'h\xac\xbd\x86') # 0x68acbd86
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.effect))
data.write(b'O\x7f\xec9') # 0x4f7fec39
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_rumble))
if self.unknown != default_override.get('unknown', Spline()):
num_properties_written += 1
data.write(b'\x05\xa4Q\xed') # 0x5a451ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.write(struct.pack(">H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
radius=data['radius'],
effect=data['effect'],
flags_rumble=data['flags_rumble'],
unknown=Spline.from_json(data['unknown']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'radius': self.radius,
'effect': self.effect,
'flags_rumble': self.flags_rumble,
'unknown': self.unknown.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_flags_rumble(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
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),
0x78c507eb: ('radius', _decode_radius),
0x68acbd86: ('effect', _decode_effect),
0x4f7fec39: ('flags_rumble', _decode_flags_rumble),
0x5a451ed: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/RumbleEffect.py | 0.61451 | 0.323447 | RumbleEffect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.GuiWidgetProperties import GuiWidgetProperties
@dataclasses.dataclass()
class GuiWidget(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_widget_properties: GuiWidgetProperties = dataclasses.field(default_factory=GuiWidgetProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GWIG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xce\xfa\x1e') # 0x91cefa1e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gui_widget_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
gui_widget_properties=GuiWidgetProperties.from_json(data['gui_widget_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_widget_properties': self.gui_widget_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_gui_widget_properties(data: typing.BinaryIO, property_size: int):
return GuiWidgetProperties.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x91cefa1e: ('gui_widget_properties', _decode_gui_widget_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GuiWidget.py | 0.570092 | 0.314537 | GuiWidget.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class IFT(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'IFTC'
@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'$\x8d\xe3|') # 0x248de37c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown,
}
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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x248de37c: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/IFT.py | 0.610337 | 0.34668 | IFT.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.TextProperties import TextProperties
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 DialogueMenu(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
japan_text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
text_position_y: int = dataclasses.field(default=100)
japan_text_position_y: int = dataclasses.field(default=100)
selected_font_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
unknown_0x69fdb265: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
selection_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
unknown_0x3c5e109a: int = dataclasses.field(default=110)
default_selection: enums.DefaultSelection = dataclasses.field(default=enums.DefaultSelection.Unknown1)
highlight_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
select_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'DGMN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0T>f') # 0xe0543e66
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.text_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8\xe4A\xfa') # 0xc8e441fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.japan_text_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{\x86\xe0\xa2') # 0x7b86e0a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_y))
data.write(b'\xeb\x1b\x90\xc2') # 0xeb1b90c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_y))
data.write(b'\xefPYe') # 0xef505965
data.write(b'\x00\x10') # size
self.selected_font_color.to_stream(data)
data.write(b'i\xfd\xb2e') # 0x69fdb265
data.write(b'\x00\x10') # size
self.unknown_0x69fdb265.to_stream(data)
data.write(b'\xd1\xb7AQ') # 0xd1b74151
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.selection_model))
data.write(b'<^\x10\x9a') # 0x3c5e109a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3c5e109a))
data.write(b'X\xcb\xcb\xca') # 0x58cbcbca
data.write(b'\x00\x04') # size
self.default_selection.to_stream(data)
data.write(b'\xe8\xfen\x9d') # 0xe8fe6e9d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.highlight_sound))
data.write(b'\x9e\x87\xe0\xeb') # 0x9e87e0eb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.select_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']),
text_properties=TextProperties.from_json(data['text_properties']),
japan_text_properties=TextProperties.from_json(data['japan_text_properties']),
text_position_y=data['text_position_y'],
japan_text_position_y=data['japan_text_position_y'],
selected_font_color=Color.from_json(data['selected_font_color']),
unknown_0x69fdb265=Color.from_json(data['unknown_0x69fdb265']),
selection_model=data['selection_model'],
unknown_0x3c5e109a=data['unknown_0x3c5e109a'],
default_selection=enums.DefaultSelection.from_json(data['default_selection']),
highlight_sound=data['highlight_sound'],
select_sound=data['select_sound'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'text_properties': self.text_properties.to_json(),
'japan_text_properties': self.japan_text_properties.to_json(),
'text_position_y': self.text_position_y,
'japan_text_position_y': self.japan_text_position_y,
'selected_font_color': self.selected_font_color.to_json(),
'unknown_0x69fdb265': self.unknown_0x69fdb265.to_json(),
'selection_model': self.selection_model,
'unknown_0x3c5e109a': self.unknown_0x3c5e109a,
'default_selection': self.default_selection.to_json(),
'highlight_sound': self.highlight_sound,
'select_sound': self.select_sound,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size)
def _decode_japan_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size)
def _decode_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_selected_font_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0x69fdb265(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_selection_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x3c5e109a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_default_selection(data: typing.BinaryIO, property_size: int):
return enums.DefaultSelection.from_stream(data)
def _decode_highlight_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_select_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),
0xe0543e66: ('text_properties', _decode_text_properties),
0xc8e441fa: ('japan_text_properties', _decode_japan_text_properties),
0x7b86e0a2: ('text_position_y', _decode_text_position_y),
0xeb1b90c2: ('japan_text_position_y', _decode_japan_text_position_y),
0xef505965: ('selected_font_color', _decode_selected_font_color),
0x69fdb265: ('unknown_0x69fdb265', _decode_unknown_0x69fdb265),
0xd1b74151: ('selection_model', _decode_selection_model),
0x3c5e109a: ('unknown_0x3c5e109a', _decode_unknown_0x3c5e109a),
0x58cbcbca: ('default_selection', _decode_default_selection),
0xe8fe6e9d: ('highlight_sound', _decode_highlight_sound),
0x9e87e0eb: ('select_sound', _decode_select_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DialogueMenu.py | 0.551332 | 0.210868 | DialogueMenu.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct59 import UnknownStruct59
@dataclasses.dataclass()
class SeedBoss2BotSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct59: UnknownStruct59 = dataclasses.field(default_factory=UnknownStruct59)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SB2X'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Gandrayda.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'\xd6\xccb\xcb') # 0xd6cc62cb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct59.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct59=UnknownStruct59.from_json(data['unknown_struct59']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct59': self.unknown_struct59.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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct59(data: typing.BinaryIO, property_size: int):
return UnknownStruct59.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xd6cc62cb: ('unknown_struct59', _decode_unknown_struct59),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SeedBoss2BotSwarm.py | 0.645008 | 0.348451 | SeedBoss2BotSwarm.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.DarkSamusData import DarkSamusData
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct27 import UnknownStruct27
@dataclasses.dataclass()
class DarkSamus(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct27: UnknownStruct27 = dataclasses.field(default_factory=UnknownStruct27)
dark_samus_properties: DarkSamusData = dataclasses.field(default_factory=DarkSamusData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
dark_samus_data: DarkSamusData = dataclasses.field(default_factory=DarkSamusData)
patterned_ai_0x1464ae05: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
dark_samus_properties_elite_difficulty: DarkSamusData = dataclasses.field(default_factory=DarkSamusData)
patterned_ai_0x24d00673: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'DRKS'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_DarkSamus.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\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'\x02\x14\xa7\xeb') # 0x214a7eb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct27.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x02\xc4<A') # 0x2c43c41
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_samus_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)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdd\x04/\xe0') # 0xdd042fe0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_samus_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14d\xae\x05') # 0x1464ae05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x1464ae05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd0b\x1c\x92') # 0xd0621c92
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_samus_properties_elite_difficulty.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xd0\x06s') # 0x24d00673
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x24d00673.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)
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_struct27=UnknownStruct27.from_json(data['unknown_struct27']),
dark_samus_properties=DarkSamusData.from_json(data['dark_samus_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
dark_samus_data=DarkSamusData.from_json(data['dark_samus_data']),
patterned_ai_0x1464ae05=PatternedAITypedef.from_json(data['patterned_ai_0x1464ae05']),
dark_samus_properties_elite_difficulty=DarkSamusData.from_json(data['dark_samus_properties_elite_difficulty']),
patterned_ai_0x24d00673=PatternedAITypedef.from_json(data['patterned_ai_0x24d00673']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct27': self.unknown_struct27.to_json(),
'dark_samus_properties': self.dark_samus_properties.to_json(),
'patterned': self.patterned.to_json(),
'dark_samus_data': self.dark_samus_data.to_json(),
'patterned_ai_0x1464ae05': self.patterned_ai_0x1464ae05.to_json(),
'dark_samus_properties_elite_difficulty': self.dark_samus_properties_elite_difficulty.to_json(),
'patterned_ai_0x24d00673': self.patterned_ai_0x24d00673.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct27(data: typing.BinaryIO, property_size: int):
return UnknownStruct27.from_stream(data, property_size)
def _decode_dark_samus_properties(data: typing.BinaryIO, property_size: int):
return DarkSamusData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_dark_samus_data(data: typing.BinaryIO, property_size: int):
return DarkSamusData.from_stream(data, property_size)
def _decode_patterned_ai_0x1464ae05(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_dark_samus_properties_elite_difficulty(data: typing.BinaryIO, property_size: int):
return DarkSamusData.from_stream(data, property_size)
def _decode_patterned_ai_0x24d00673(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x214a7eb: ('unknown_struct27', _decode_unknown_struct27),
0x2c43c41: ('dark_samus_properties', _decode_dark_samus_properties),
0xb3774750: ('patterned', _decode_patterned),
0xdd042fe0: ('dark_samus_data', _decode_dark_samus_data),
0x1464ae05: ('patterned_ai_0x1464ae05', _decode_patterned_ai_0x1464ae05),
0xd0621c92: ('dark_samus_properties_elite_difficulty', _decode_dark_samus_properties_elite_difficulty),
0x24d00673: ('patterned_ai_0x24d00673', _decode_patterned_ai_0x24d00673),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DarkSamus.py | 0.521959 | 0.322406 | DarkSamus.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class PathControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
path_flags: int = dataclasses.field(default=0) # Flagset
path_curve_type: enums.PathCurveType = dataclasses.field(default=enums.PathCurveType.Unknown1)
radius_control: Spline = dataclasses.field(default_factory=Spline)
height_control: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PCTL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb0\xb9\x7f\x9f') # 0xb0b97f9f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.path_flags))
data.write(b'\xf2_\xfd\xff') # 0xf25ffdff
data.write(b'\x00\x04') # size
self.path_curve_type.to_stream(data)
data.write(b'\xf8\xaf\x85\x8c') # 0xf8af858c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.radius_control.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'r\xcd`\xce') # 0x72cd60ce
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.height_control.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']),
path_flags=data['path_flags'],
path_curve_type=enums.PathCurveType.from_json(data['path_curve_type']),
radius_control=Spline.from_json(data['radius_control']),
height_control=Spline.from_json(data['height_control']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'path_flags': self.path_flags,
'path_curve_type': self.path_curve_type.to_json(),
'radius_control': self.radius_control.to_json(),
'height_control': self.height_control.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_path_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_path_curve_type(data: typing.BinaryIO, property_size: int):
return enums.PathCurveType.from_stream(data)
def _decode_radius_control(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_height_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]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb0b97f9f: ('path_flags', _decode_path_flags),
0xf25ffdff: ('path_curve_type', _decode_path_curve_type),
0xf8af858c: ('radius_control', _decode_radius_control),
0x72cd60ce: ('height_control', _decode_height_control),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PathControl.py | 0.64579 | 0.303409 | PathControl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Ripple(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
energy: float = dataclasses.field(default=0.20000000298023224)
splash: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'RIPL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptWater.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'is\x1a\x91') # 0x69731a91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.energy))
data.write(b'DA1\xdf') # 0x444131df
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.splash))
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']),
energy=data['energy'],
splash=data['splash'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'energy': self.energy,
'splash': self.splash,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_energy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_splash(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),
0x69731a91: ('energy', _decode_energy),
0x444131df: ('splash', _decode_splash),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Ripple.py | 0.665845 | 0.368349 | Ripple.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Color import Color
@dataclasses.dataclass()
class FogVolume(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fog_bob_height: float = dataclasses.field(default=0.0)
fog_bob_freq: float = dataclasses.field(default=1.0)
fog_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOGV'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\r\xffD') # 0xb90dff44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fog_bob_height))
data.write(b'\xf6\x08\xd3\\') # 0xf608d35c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fog_bob_freq))
data.write(b'\xe5x\xc0\xdd') # 0xe578c0dd
data.write(b'\x00\x10') # size
self.fog_color.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
fog_bob_height=data['fog_bob_height'],
fog_bob_freq=data['fog_bob_freq'],
fog_color=Color.from_json(data['fog_color']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'fog_bob_height': self.fog_bob_height,
'fog_bob_freq': self.fog_bob_freq,
'fog_color': self.fog_color.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_fog_bob_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fog_bob_freq(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fog_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb90dff44: ('fog_bob_height', _decode_fog_bob_height),
0xf608d35c: ('fog_bob_freq', _decode_fog_bob_freq),
0xe578c0dd: ('fog_color', _decode_fog_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FogVolume.py | 0.683631 | 0.311951 | FogVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SpiderBallWaypoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'BALW'
@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']\x81t\x83') # 0x5d817483
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags))
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=data['flags'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags': self.flags,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags(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),
0x5d817483: ('flags', _decode_flags),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SpiderBallWaypoint.py | 0.596903 | 0.348811 | SpiderBallWaypoint.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.BeastRiderData import BeastRiderData
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class BeastRider(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
beast_rider_properties: BeastRiderData = dataclasses.field(default_factory=BeastRiderData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'BSTR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_BeastRider.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'V\xc4\x81A') # 0x56c48141
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beast_rider_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)
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)
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']),
beast_rider_properties=BeastRiderData.from_json(data['beast_rider_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'beast_rider_properties': self.beast_rider_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_beast_rider_properties(data: typing.BinaryIO, property_size: int):
return BeastRiderData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x56c48141: ('beast_rider_properties', _decode_beast_rider_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/BeastRider.py | 0.621196 | 0.356223 | BeastRider.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class SurfaceControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
surface_type: enums.SurfaceType = dataclasses.field(default=enums.SurfaceType.Unknown1)
spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SCTL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa4+qI') # 0xa42b7149
data.write(b'\x00\x04') # size
self.surface_type.to_stream(data)
data.write(b'\x92-\x15\x1f') # 0x922d151f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
surface_type=enums.SurfaceType.from_json(data['surface_type']),
spline=Spline.from_json(data['spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'surface_type': self.surface_type.to_json(),
'spline': self.spline.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_surface_type(data: typing.BinaryIO, property_size: int):
return enums.SurfaceType.from_stream(data)
def _decode_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa42b7149: ('surface_type', _decode_surface_type),
0x922d151f: ('spline', _decode_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SurfaceControl.py | 0.61173 | 0.340047 | SurfaceControl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct52 import UnknownStruct52
from retro_data_structures.properties.corruption.archetypes.WallCrawlerData import WallCrawlerData
@dataclasses.dataclass()
class PillBug(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
wall_crawler_data: WallCrawlerData = dataclasses.field(default_factory=WallCrawlerData)
unknown_struct52: UnknownStruct52 = dataclasses.field(default_factory=UnknownStruct52)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'PILL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PillBug.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'detection_range': 10.0, 'max_attack_range': 30.0})
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'\xe6\x86\x11g') # 0xe6861167
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.wall_crawler_data.to_stream(data, default_override={'stick_radius': 0.20000000298023224, 'floor_turn_speed': 120.0, 'waypoint_approach_distance': 1.5, 'visible_distance': 200.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0e\xbem\xcb') # 0xebe6dcb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct52.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']),
actor_information=ActorParameters.from_json(data['actor_information']),
wall_crawler_data=WallCrawlerData.from_json(data['wall_crawler_data']),
unknown_struct52=UnknownStruct52.from_json(data['unknown_struct52']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'wall_crawler_data': self.wall_crawler_data.to_json(),
'unknown_struct52': self.unknown_struct52.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={'detection_range': 10.0, 'max_attack_range': 30.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_wall_crawler_data(data: typing.BinaryIO, property_size: int):
return WallCrawlerData.from_stream(data, property_size, default_override={'stick_radius': 0.20000000298023224, 'floor_turn_speed': 120.0, 'waypoint_approach_distance': 1.5, 'visible_distance': 200.0})
def _decode_unknown_struct52(data: typing.BinaryIO, property_size: int):
return UnknownStruct52.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xe6861167: ('wall_crawler_data', _decode_wall_crawler_data),
0xebe6dcb: ('unknown_struct52', _decode_unknown_struct52),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PillBug.py | 0.619932 | 0.349172 | PillBug.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.ScannableParameters import ScannableParameters
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class PointOfInterest(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
scan_info: ScannableParameters = dataclasses.field(default_factory=ScannableParameters)
scan_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
look_at_poi: bool = dataclasses.field(default=False)
scan_offset_local: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'POIN'
@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'\xbd\xbe\xc2\x95') # 0xbdbec295
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x86<\x16\xe3') # 0x863c16e3
data.write(b'\x00\x0c') # size
self.scan_offset.to_stream(data)
data.write(b'\x01\xf9\xc5\xbb') # 0x1f9c5bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.look_at_poi))
data.write(b'\x915\x1bi') # 0x91351b69
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scan_offset_local))
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']),
scan_info=ScannableParameters.from_json(data['scan_info']),
scan_offset=Vector.from_json(data['scan_offset']),
look_at_poi=data['look_at_poi'],
scan_offset_local=data['scan_offset_local'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'scan_info': self.scan_info.to_json(),
'scan_offset': self.scan_offset.to_json(),
'look_at_poi': self.look_at_poi,
'scan_offset_local': self.scan_offset_local,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_scan_info(data: typing.BinaryIO, property_size: int):
return ScannableParameters.from_stream(data, property_size)
def _decode_scan_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_look_at_poi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scan_offset_local(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),
0xbdbec295: ('scan_info', _decode_scan_info),
0x863c16e3: ('scan_offset', _decode_scan_offset),
0x1f9c5bb: ('look_at_poi', _decode_look_at_poi),
0x91351b69: ('scan_offset_local', _decode_scan_offset_local),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PointOfInterest.py | 0.604749 | 0.357371 | PointOfInterest.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct45 import UnknownStruct45
@dataclasses.dataclass()
class MinorIng(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct45: UnknownStruct45 = dataclasses.field(default_factory=UnknownStruct45)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'MINI'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MinorIng.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'collision_height': 4.0, 'min_attack_range': 4.5, 'max_attack_range': 30.0, 'average_attack_time': 3.0})
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'\xa3\xa2\xac?') # 0xa3a2ac3f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct45.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']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_struct45=UnknownStruct45.from_json(data['unknown_struct45']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct45': self.unknown_struct45.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_height': 4.0, 'min_attack_range': 4.5, 'max_attack_range': 30.0, 'average_attack_time': 3.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct45(data: typing.BinaryIO, property_size: int):
return UnknownStruct45.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa3a2ac3f: ('unknown_struct45', _decode_unknown_struct45),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MinorIng.py | 0.646014 | 0.321913 | MinorIng.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TargetingPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'TGPT'
@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, default_override={'active': False})
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, default_override={'active': False})
_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/corruption/objects/TargetingPoint.py | 0.578805 | 0.345878 | TargetingPoint.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.Inventory import Inventory
@dataclasses.dataclass()
class SpawnPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
first_spawn: bool = dataclasses.field(default=True)
morphed: bool = dataclasses.field(default=False)
unknown_0xa7a88fef: bool = dataclasses.field(default=False)
death_fall: bool = dataclasses.field(default=False)
unknown_0xab0b9ac4: bool = dataclasses.field(default=False)
unknown_0x4ad656da: bool = dataclasses.field(default=False)
inventory_player: Inventory = dataclasses.field(default_factory=Inventory)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPWN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\xe4R\x1b') # 0xc0e4521b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.first_spawn))
data.write(b'\xb9\xc4\x0f\x92') # 0xb9c40f92
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.morphed))
data.write(b'\xa7\xa8\x8f\xef') # 0xa7a88fef
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa7a88fef))
data.write(b'!\x0f&&') # 0x210f2626
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.death_fall))
data.write(b'\xab\x0b\x9a\xc4') # 0xab0b9ac4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xab0b9ac4))
data.write(b'J\xd6V\xda') # 0x4ad656da
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4ad656da))
data.write(b'\xf4\xed\x95G') # 0xf4ed9547
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.inventory_player.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']),
first_spawn=data['first_spawn'],
morphed=data['morphed'],
unknown_0xa7a88fef=data['unknown_0xa7a88fef'],
death_fall=data['death_fall'],
unknown_0xab0b9ac4=data['unknown_0xab0b9ac4'],
unknown_0x4ad656da=data['unknown_0x4ad656da'],
inventory_player=Inventory.from_json(data['inventory_player']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'first_spawn': self.first_spawn,
'morphed': self.morphed,
'unknown_0xa7a88fef': self.unknown_0xa7a88fef,
'death_fall': self.death_fall,
'unknown_0xab0b9ac4': self.unknown_0xab0b9ac4,
'unknown_0x4ad656da': self.unknown_0x4ad656da,
'inventory_player': self.inventory_player.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_first_spawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_morphed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa7a88fef(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_death_fall(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xab0b9ac4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4ad656da(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_inventory_player(data: typing.BinaryIO, property_size: int):
return Inventory.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),
0xc0e4521b: ('first_spawn', _decode_first_spawn),
0xb9c40f92: ('morphed', _decode_morphed),
0xa7a88fef: ('unknown_0xa7a88fef', _decode_unknown_0xa7a88fef),
0x210f2626: ('death_fall', _decode_death_fall),
0xab0b9ac4: ('unknown_0xab0b9ac4', _decode_unknown_0xab0b9ac4),
0x4ad656da: ('unknown_0x4ad656da', _decode_unknown_0x4ad656da),
0xf4ed9547: ('inventory_player', _decode_inventory_player),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SpawnPoint.py | 0.553988 | 0.365117 | SpawnPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TimeKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TKEY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
time=data['time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44335aff: ('time', _decode_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/TimeKeyframe.py | 0.651687 | 0.359308 | TimeKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.MultiModelInformation import MultiModelInformation
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
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class MultiModelActor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
multi_model_information: MultiModelInformation = dataclasses.field(default_factory=MultiModelInformation)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown: bool = dataclasses.field(default=False)
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)
orbit_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
orbit_offset_local: bool = dataclasses.field(default=True)
is_solid: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MMDL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptMultiModelActor.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x19`\x93-') # 0x1960932d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.multi_model_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa0\x9dJ\x1f') # 0xa09d4a1f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
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'\x85\x01\x15\xe4') # 0x850115e4
data.write(b'\x00\x0c') # size
self.orbit_offset.to_stream(data)
data.write(b'\xe7?\x12=') # 0xe73f123d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orbit_offset_local))
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
collision_model=data['collision_model'],
model=data['model'],
multi_model_information=MultiModelInformation.from_json(data['multi_model_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown=data['unknown'],
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']),
orbit_offset=Vector.from_json(data['orbit_offset']),
orbit_offset_local=data['orbit_offset_local'],
is_solid=data['is_solid'],
immovable=data['immovable'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'collision_model': self.collision_model,
'model': self.model,
'multi_model_information': self.multi_model_information.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown': self.unknown,
'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(),
'orbit_offset': self.orbit_offset.to_json(),
'orbit_offset_local': self.orbit_offset_local,
'is_solid': self.is_solid,
'immovable': self.immovable,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_multi_model_information(data: typing.BinaryIO, property_size: int):
return MultiModelInformation.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown(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_orbit_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_orbit_offset_local(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_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xfc966dc: ('collision_model', _decode_collision_model),
0xc27ffa8f: ('model', _decode_model),
0x1960932d: ('multi_model_information', _decode_multi_model_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa09d4a1f: ('unknown', _decode_unknown),
0xb530d7de: ('use_mod_inca', _decode_use_mod_inca),
0xf8df6cd2: ('mod_inca_color', _decode_mod_inca_color),
0xc23011d9: ('mod_inca_amount', _decode_mod_inca_amount),
0x850115e4: ('orbit_offset', _decode_orbit_offset),
0xe73f123d: ('orbit_offset_local', _decode_orbit_offset_local),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x1e32523e: ('immovable', _decode_immovable),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MultiModelActor.py | 0.583085 | 0.254006 | MultiModelActor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.FlareDef import FlareDef
@dataclasses.dataclass()
class VisorFlare(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
blend_mode: int = dataclasses.field(default=0)
constant_scale: bool = dataclasses.field(default=True)
fade_time: float = dataclasses.field(default=0.10000000149011612)
fade_factor: float = dataclasses.field(default=1.0)
rotate_factor: float = dataclasses.field(default=2.0)
combat_visor_mode: int = dataclasses.field(default=0)
unknown: bool = dataclasses.field(default=True)
no_occlusion_test: bool = dataclasses.field(default=False)
flare1: FlareDef = dataclasses.field(default_factory=FlareDef)
flare2: FlareDef = dataclasses.field(default_factory=FlareDef)
flare3: FlareDef = dataclasses.field(default_factory=FlareDef)
flare4: FlareDef = dataclasses.field(default_factory=FlareDef)
flare5: FlareDef = dataclasses.field(default_factory=FlareDef)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'FLAR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\x13\xefF') # 0xcb13ef46
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blend_mode))
data.write(b'\xe0\xc5\xfc\x06') # 0xe0c5fc06
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.constant_scale))
data.write(b'\xd4\x12LL') # 0xd4124c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_time))
data.write(b'\xd6\xfb1\xbf') # 0xd6fb31bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_factor))
data.write(b'1a\xf3\x8c') # 0x3161f38c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotate_factor))
data.write(b'C\xb5\x03\xa6') # 0x43b503a6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.combat_visor_mode))
data.write(b'\xa5\x1f$>') # 0xa51f243e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x05\x08\x81\xa9') # 0x50881a9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_occlusion_test))
data.write(b'<%r#') # 0x3c257223
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05\xa8N\xe6') # 0x5a84ee6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare2.to_stream(data, default_override={'position': 0.25})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\xd3Z\xa5') # 0x12d35aa5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare3.to_stream(data, default_override={'position': 0.5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\xb27l') # 0x76b2376c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare4.to_stream(data, default_override={'position': 0.75})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\xc9#/') # 0x61c9232f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare5.to_stream(data, default_override={'position': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
blend_mode=data['blend_mode'],
constant_scale=data['constant_scale'],
fade_time=data['fade_time'],
fade_factor=data['fade_factor'],
rotate_factor=data['rotate_factor'],
combat_visor_mode=data['combat_visor_mode'],
unknown=data['unknown'],
no_occlusion_test=data['no_occlusion_test'],
flare1=FlareDef.from_json(data['flare1']),
flare2=FlareDef.from_json(data['flare2']),
flare3=FlareDef.from_json(data['flare3']),
flare4=FlareDef.from_json(data['flare4']),
flare5=FlareDef.from_json(data['flare5']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'blend_mode': self.blend_mode,
'constant_scale': self.constant_scale,
'fade_time': self.fade_time,
'fade_factor': self.fade_factor,
'rotate_factor': self.rotate_factor,
'combat_visor_mode': self.combat_visor_mode,
'unknown': self.unknown,
'no_occlusion_test': self.no_occlusion_test,
'flare1': self.flare1.to_json(),
'flare2': self.flare2.to_json(),
'flare3': self.flare3.to_json(),
'flare4': self.flare4.to_json(),
'flare5': self.flare5.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_constant_scale(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_fade_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotate_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_combat_visor_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_no_occlusion_test(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flare1(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size)
def _decode_flare2(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 0.25})
def _decode_flare3(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 0.5})
def _decode_flare4(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 0.75})
def _decode_flare5(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 1.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcb13ef46: ('blend_mode', _decode_blend_mode),
0xe0c5fc06: ('constant_scale', _decode_constant_scale),
0xd4124c4c: ('fade_time', _decode_fade_time),
0xd6fb31bf: ('fade_factor', _decode_fade_factor),
0x3161f38c: ('rotate_factor', _decode_rotate_factor),
0x43b503a6: ('combat_visor_mode', _decode_combat_visor_mode),
0xa51f243e: ('unknown', _decode_unknown),
0x50881a9: ('no_occlusion_test', _decode_no_occlusion_test),
0x3c257223: ('flare1', _decode_flare1),
0x5a84ee6: ('flare2', _decode_flare2),
0x12d35aa5: ('flare3', _decode_flare3),
0x76b2376c: ('flare4', _decode_flare4),
0x61c9232f: ('flare5', _decode_flare5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/VisorFlare.py | 0.507812 | 0.334834 | VisorFlare.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class GuiScreen(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
which_screen: int = dataclasses.field(default=0)
string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'GSCR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptGUIScreenFrontEndUI.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd3\xb7\xe6\xd8') # 0xd3b7e6d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_screen))
data.write(b'\xfd\x95\xed*') # 0xfd95ed2a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.string_table))
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']),
which_screen=data['which_screen'],
string_table=data['string_table'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'which_screen': self.which_screen,
'string_table': self.string_table,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_which_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd3b7e6d8: ('which_screen', _decode_which_screen),
0xfd95ed2a: ('string_table', _decode_string_table),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GuiScreen.py | 0.563978 | 0.319413 | GuiScreen.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.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ScrewAttackWallJumpTarget(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SWJT'
@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/corruption/objects/ScrewAttackWallJumpTarget.py | 0.582491 | 0.342654 | ScrewAttackWallJumpTarget.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SpecialFunction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
function: enums.Function = dataclasses.field(default=enums.Function.What)
string_parm: str = dataclasses.field(default='')
value_parm: float = dataclasses.field(default=0.0)
value_parm2: float = dataclasses.field(default=0.0)
value_parm3: float = dataclasses.field(default=0.0)
value_parm4: float = dataclasses.field(default=0.0)
int_parm1: int = dataclasses.field(default=0)
int_parm2: int = dataclasses.field(default=0)
inventory_item_parm: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
sound1: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
sound2: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
sound3: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
extra_info: enums.ExtraInfo = dataclasses.field(default=enums.ExtraInfo.Unknown1)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPFN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8\xaf\xcf!') # 0xb8afcf21
data.write(b'\x00\x04') # size
self.function.to_stream(data)
data.write(b'\x9dzWm') # 0x9d7a576d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.string_parm.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\x02\x80\x99') # 0x19028099
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm))
data.write(b',\x93\xaa\xf5') # 0x2c93aaf5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm2))
data.write(b'\xe7\xcfyP') # 0xe7cf7950
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm3))
data.write(b'\xfa\xcaI\xe8') # 0xfaca49e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm4))
data.write(b'\xa74\xf8\xa5') # 0xa734f8a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.int_parm1))
data.write(b'\xb5\x81WK') # 0xb581574b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.int_parm2))
data.write(b'?\xa1d\xbc') # 0x3fa164bc
data.write(b'\x00\x04') # size
self.inventory_item_parm.to_stream(data)
data.write(b'^\xcf\x8fg') # 0x5ecf8f67
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound1))
data.write(b'\xd8[\xfd\xc9') # 0xd85bfdc9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound2))
data.write(b'\x13\x07.l') # 0x13072e6c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound3))
data.write(b'\x82^\x1e\x14') # 0x825e1e14
data.write(b'\x00\x04') # size
self.extra_info.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
function=enums.Function.from_json(data['function']),
string_parm=data['string_parm'],
value_parm=data['value_parm'],
value_parm2=data['value_parm2'],
value_parm3=data['value_parm3'],
value_parm4=data['value_parm4'],
int_parm1=data['int_parm1'],
int_parm2=data['int_parm2'],
inventory_item_parm=enums.PlayerItem.from_json(data['inventory_item_parm']),
sound1=data['sound1'],
sound2=data['sound2'],
sound3=data['sound3'],
extra_info=enums.ExtraInfo.from_json(data['extra_info']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'function': self.function.to_json(),
'string_parm': self.string_parm,
'value_parm': self.value_parm,
'value_parm2': self.value_parm2,
'value_parm3': self.value_parm3,
'value_parm4': self.value_parm4,
'int_parm1': self.int_parm1,
'int_parm2': self.int_parm2,
'inventory_item_parm': self.inventory_item_parm.to_json(),
'sound1': self.sound1,
'sound2': self.sound2,
'sound3': self.sound3,
'extra_info': self.extra_info.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_function(data: typing.BinaryIO, property_size: int):
return enums.Function.from_stream(data)
def _decode_string_parm(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_value_parm(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_int_parm1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_int_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_inventory_item_parm(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_sound1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_sound3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_extra_info(data: typing.BinaryIO, property_size: int):
return enums.ExtraInfo.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb8afcf21: ('function', _decode_function),
0x9d7a576d: ('string_parm', _decode_string_parm),
0x19028099: ('value_parm', _decode_value_parm),
0x2c93aaf5: ('value_parm2', _decode_value_parm2),
0xe7cf7950: ('value_parm3', _decode_value_parm3),
0xfaca49e8: ('value_parm4', _decode_value_parm4),
0xa734f8a5: ('int_parm1', _decode_int_parm1),
0xb581574b: ('int_parm2', _decode_int_parm2),
0x3fa164bc: ('inventory_item_parm', _decode_inventory_item_parm),
0x5ecf8f67: ('sound1', _decode_sound1),
0xd85bfdc9: ('sound2', _decode_sound2),
0x13072e6c: ('sound3', _decode_sound3),
0x825e1e14: ('extra_info', _decode_extra_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SpecialFunction.py | 0.549641 | 0.264692 | SpecialFunction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.DynamicLightFalloff import DynamicLightFalloff
from retro_data_structures.properties.corruption.archetypes.DynamicLightIntensity import DynamicLightIntensity
from retro_data_structures.properties.corruption.archetypes.DynamicLightMotionSpline import DynamicLightMotionSpline
from retro_data_structures.properties.corruption.archetypes.DynamicLightParent import DynamicLightParent
from retro_data_structures.properties.corruption.archetypes.DynamicLightSpotlight import DynamicLightSpotlight
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Color import Color
@dataclasses.dataclass()
class DynamicLight(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
light_type: int = dataclasses.field(default=2)
unknown_0xe42bab04: bool = dataclasses.field(default=True)
unknown_0x364a7b36: bool = dataclasses.field(default=True)
unknown_0x4ea02861: bool = dataclasses.field(default=True)
unknown_0xa502605d: bool = dataclasses.field(default=True)
unknown_0xa19817f0: bool = dataclasses.field(default=True)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
intensity: DynamicLightIntensity = dataclasses.field(default_factory=DynamicLightIntensity)
falloff: DynamicLightFalloff = dataclasses.field(default_factory=DynamicLightFalloff)
spotlight: DynamicLightSpotlight = dataclasses.field(default_factory=DynamicLightSpotlight)
motion_spline: DynamicLightMotionSpline = dataclasses.field(default_factory=DynamicLightMotionSpline)
parent: DynamicLightParent = dataclasses.field(default_factory=DynamicLightParent)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DLHT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x7f\xc4\xe36') # 0x7fc4e336
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.light_type))
data.write(b'\xe4+\xab\x04') # 0xe42bab04
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe42bab04))
data.write(b'6J{6') # 0x364a7b36
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x364a7b36))
data.write(b'N\xa0(a') # 0x4ea02861
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4ea02861))
data.write(b'\xa5\x02`]') # 0xa502605d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa502605d))
data.write(b'\xa1\x98\x17\xf0') # 0xa19817f0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa19817f0))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'rS\x1e\xde') # 0x72531ede
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.intensity.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\x9bR\xda') # 0x219b52da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.falloff.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95F\xf4I') # 0x9546f449
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spotlight.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x142!8') # 0x14322138
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf74\xdf\x8c') # 0xf734df8c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.parent.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
light_type=data['light_type'],
unknown_0xe42bab04=data['unknown_0xe42bab04'],
unknown_0x364a7b36=data['unknown_0x364a7b36'],
unknown_0x4ea02861=data['unknown_0x4ea02861'],
unknown_0xa502605d=data['unknown_0xa502605d'],
unknown_0xa19817f0=data['unknown_0xa19817f0'],
color=Color.from_json(data['color']),
intensity=DynamicLightIntensity.from_json(data['intensity']),
falloff=DynamicLightFalloff.from_json(data['falloff']),
spotlight=DynamicLightSpotlight.from_json(data['spotlight']),
motion_spline=DynamicLightMotionSpline.from_json(data['motion_spline']),
parent=DynamicLightParent.from_json(data['parent']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'light_type': self.light_type,
'unknown_0xe42bab04': self.unknown_0xe42bab04,
'unknown_0x364a7b36': self.unknown_0x364a7b36,
'unknown_0x4ea02861': self.unknown_0x4ea02861,
'unknown_0xa502605d': self.unknown_0xa502605d,
'unknown_0xa19817f0': self.unknown_0xa19817f0,
'color': self.color.to_json(),
'intensity': self.intensity.to_json(),
'falloff': self.falloff.to_json(),
'spotlight': self.spotlight.to_json(),
'motion_spline': self.motion_spline.to_json(),
'parent': self.parent.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_light_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xe42bab04(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x364a7b36(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4ea02861(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa502605d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa19817f0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_intensity(data: typing.BinaryIO, property_size: int):
return DynamicLightIntensity.from_stream(data, property_size)
def _decode_falloff(data: typing.BinaryIO, property_size: int):
return DynamicLightFalloff.from_stream(data, property_size)
def _decode_spotlight(data: typing.BinaryIO, property_size: int):
return DynamicLightSpotlight.from_stream(data, property_size)
def _decode_motion_spline(data: typing.BinaryIO, property_size: int):
return DynamicLightMotionSpline.from_stream(data, property_size)
def _decode_parent(data: typing.BinaryIO, property_size: int):
return DynamicLightParent.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7fc4e336: ('light_type', _decode_light_type),
0xe42bab04: ('unknown_0xe42bab04', _decode_unknown_0xe42bab04),
0x364a7b36: ('unknown_0x364a7b36', _decode_unknown_0x364a7b36),
0x4ea02861: ('unknown_0x4ea02861', _decode_unknown_0x4ea02861),
0xa502605d: ('unknown_0xa502605d', _decode_unknown_0xa502605d),
0xa19817f0: ('unknown_0xa19817f0', _decode_unknown_0xa19817f0),
0x37c7d09d: ('color', _decode_color),
0x72531ede: ('intensity', _decode_intensity),
0x219b52da: ('falloff', _decode_falloff),
0x9546f449: ('spotlight', _decode_spotlight),
0x14322138: ('motion_spline', _decode_motion_spline),
0xf734df8c: ('parent', _decode_parent),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DynamicLight.py | 0.594787 | 0.306546 | DynamicLight.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.DefenseMechanoidData import DefenseMechanoidData
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.corruption.archetypes.UnknownStruct26 import UnknownStruct26
@dataclasses.dataclass()
class DefenseMechanoid(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct26: UnknownStruct26 = dataclasses.field(default_factory=UnknownStruct26)
defense_mechanoid_data_0x5231ed05: DefenseMechanoidData = dataclasses.field(default_factory=DefenseMechanoidData)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
defense_mechanoid_data_0x8e34b059: DefenseMechanoidData = dataclasses.field(default_factory=DefenseMechanoidData)
patterned_ai_0x1464ae05: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
defense_mechanoid_data_0x838ee838: DefenseMechanoidData = dataclasses.field(default_factory=DefenseMechanoidData)
patterned_ai_0x24d00673: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'DEFM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_DefenseMechanoid.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\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'\xf0\xceSr') # 0xf0ce5372
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct26.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'R1\xed\x05') # 0x5231ed05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.defense_mechanoid_data_0x5231ed05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8e4\xb0Y') # 0x8e34b059
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.defense_mechanoid_data_0x8e34b059.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x14d\xae\x05') # 0x1464ae05
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x1464ae05.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x83\x8e\xe88') # 0x838ee838
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.defense_mechanoid_data_0x838ee838.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xd0\x06s') # 0x24d00673
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned_ai_0x24d00673.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)
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_struct26=UnknownStruct26.from_json(data['unknown_struct26']),
defense_mechanoid_data_0x5231ed05=DefenseMechanoidData.from_json(data['defense_mechanoid_data_0x5231ed05']),
patterned=PatternedAITypedef.from_json(data['patterned']),
defense_mechanoid_data_0x8e34b059=DefenseMechanoidData.from_json(data['defense_mechanoid_data_0x8e34b059']),
patterned_ai_0x1464ae05=PatternedAITypedef.from_json(data['patterned_ai_0x1464ae05']),
defense_mechanoid_data_0x838ee838=DefenseMechanoidData.from_json(data['defense_mechanoid_data_0x838ee838']),
patterned_ai_0x24d00673=PatternedAITypedef.from_json(data['patterned_ai_0x24d00673']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct26': self.unknown_struct26.to_json(),
'defense_mechanoid_data_0x5231ed05': self.defense_mechanoid_data_0x5231ed05.to_json(),
'patterned': self.patterned.to_json(),
'defense_mechanoid_data_0x8e34b059': self.defense_mechanoid_data_0x8e34b059.to_json(),
'patterned_ai_0x1464ae05': self.patterned_ai_0x1464ae05.to_json(),
'defense_mechanoid_data_0x838ee838': self.defense_mechanoid_data_0x838ee838.to_json(),
'patterned_ai_0x24d00673': self.patterned_ai_0x24d00673.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct26(data: typing.BinaryIO, property_size: int):
return UnknownStruct26.from_stream(data, property_size)
def _decode_defense_mechanoid_data_0x5231ed05(data: typing.BinaryIO, property_size: int):
return DefenseMechanoidData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_defense_mechanoid_data_0x8e34b059(data: typing.BinaryIO, property_size: int):
return DefenseMechanoidData.from_stream(data, property_size)
def _decode_patterned_ai_0x1464ae05(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_defense_mechanoid_data_0x838ee838(data: typing.BinaryIO, property_size: int):
return DefenseMechanoidData.from_stream(data, property_size)
def _decode_patterned_ai_0x24d00673(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf0ce5372: ('unknown_struct26', _decode_unknown_struct26),
0x5231ed05: ('defense_mechanoid_data_0x5231ed05', _decode_defense_mechanoid_data_0x5231ed05),
0xb3774750: ('patterned', _decode_patterned),
0x8e34b059: ('defense_mechanoid_data_0x8e34b059', _decode_defense_mechanoid_data_0x8e34b059),
0x1464ae05: ('patterned_ai_0x1464ae05', _decode_patterned_ai_0x1464ae05),
0x838ee838: ('defense_mechanoid_data_0x838ee838', _decode_defense_mechanoid_data_0x838ee838),
0x24d00673: ('patterned_ai_0x24d00673', _decode_patterned_ai_0x24d00673),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DefenseMechanoid.py | 0.526343 | 0.297146 | DefenseMechanoid.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.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.MysteryFlyerData import MysteryFlyerData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class MysteryFlyer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
mystery_flyer_properties: MysteryFlyerData = dataclasses.field(default_factory=MysteryFlyerData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'MYSF'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MysteryFlyer.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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'D\x08\x05e') # 0x44080565
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mystery_flyer_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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
mystery_flyer_properties=MysteryFlyerData.from_json(data['mystery_flyer_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'mystery_flyer_properties': self.mystery_flyer_properties.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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_mystery_flyer_properties(data: typing.BinaryIO, property_size: int):
return MysteryFlyerData.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),
0x7e397fed: ('actor_information', _decode_actor_information),
0x44080565: ('mystery_flyer_properties', _decode_mystery_flyer_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MysteryFlyer.py | 0.593845 | 0.321274 | MysteryFlyer.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.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.FishCloudAggressionData import FishCloudAggressionData
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 FishCloud(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fish_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
fish_count: int = dataclasses.field(default=20)
fish_scale: float = dataclasses.field(default=0.0)
speed: float = dataclasses.field(default=3.0)
maximum_turn_angle: float = dataclasses.field(default=0.0)
influence_distance: float = dataclasses.field(default=2.0)
unknown_0x61959f0d: float = dataclasses.field(default=0.4000000059604645)
alignment_priority: float = dataclasses.field(default=0.8999999761581421)
separation_priority: float = dataclasses.field(default=1.0)
projectile_priority: float = dataclasses.field(default=1.0)
player_priority: float = dataclasses.field(default=0.4000000059604645)
containment_priority: float = dataclasses.field(default=0.20000000298023224)
wander_priority: float = dataclasses.field(default=0.0)
wander_amount: float = dataclasses.field(default=0.0)
player_ball_priority: float = dataclasses.field(default=0.0)
player_ball_distance: float = dataclasses.field(default=30.0)
projectile_decay_rate: float = dataclasses.field(default=0.10000000149011612)
player_decay_rate: float = dataclasses.field(default=0.10000000149011612)
look_ahead_time: float = dataclasses.field(default=0.5)
update_frame: int = dataclasses.field(default=3)
unknown_0x9939d085: int = dataclasses.field(default=3257279650) # Choice
material_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
can_be_killed: bool = dataclasses.field(default=False)
collision_radius: float = dataclasses.field(default=0.0)
respawn_wait_time: float = dataclasses.field(default=0.0)
respawn_fade_time: float = dataclasses.field(default=0.0)
death_effect0: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death_effect0_count: int = dataclasses.field(default=0)
death_effect0_scale: float = dataclasses.field(default=1.0)
death_effect1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death_effect1_count: int = dataclasses.field(default=0)
death_effect1_scale: float = dataclasses.field(default=1.0)
death_effect2: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
death_effect2_count: int = dataclasses.field(default=0)
death_effect2_scale: float = dataclasses.field(default=1.0)
death_effect3: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
death_effect3_count: int = dataclasses.field(default=0)
death_effect3_scale: float = dataclasses.field(default=1.0)
death_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
looped_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
unknown_0xd7bce5da: float = dataclasses.field(default=20.0)
unknown_0xe8b7e32e: float = dataclasses.field(default=25.0)
unknown_0xc320a050: bool = dataclasses.field(default=True)
unknown_0xcd4c81a1: bool = dataclasses.field(default=True)
aggression_data: FishCloudAggressionData = dataclasses.field(default_factory=FishCloudAggressionData)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'FISH'
@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/') # 47 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'y\x90\xa3\xb6') # 0x7990a3b6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.fish_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'"d\x06.') # 0x2264062e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fish_count))
data.write(b'\x97\xbe\xffO') # 0x97beff4f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fish_scale))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'\xcb\xabT\xc1') # 0xcbab54c1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_turn_angle))
data.write(b'xd\xad\x0e') # 0x7864ad0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.influence_distance))
data.write(b'a\x95\x9f\r') # 0x61959f0d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61959f0d))
data.write(b'HA\xf1\xde') # 0x4841f1de
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alignment_priority))
data.write(b'\xd2\x93\xeb\xc4') # 0xd293ebc4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_priority))
data.write(b'_6*\x14') # 0x5f362a14
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_priority))
data.write(b'\xec\x9bs\xc2') # 0xec9b73c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_priority))
data.write(b'\x7f\xf1F\x9e') # 0x7ff1469e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.containment_priority))
data.write(b'|\xe1xp') # 0x7ce17870
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wander_priority))
data.write(b':%\xf0\x9d') # 0x3a25f09d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wander_amount))
data.write(b'#\xa1`\xf3') # 0x23a160f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_ball_priority))
data.write(b'\xf0g\x14\x10') # 0xf0671410
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_ball_distance))
data.write(b'\xa1trh') # 0xa1747268
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_decay_rate))
data.write(b'\xcew\xa8\xd0') # 0xce77a8d0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_decay_rate))
data.write(b'\x8c\xb2\x0cS') # 0x8cb20c53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_ahead_time))
data.write(b'!\xb3\xd0|') # 0x21b3d07c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.update_frame))
data.write(b'\x999\xd0\x85') # 0x9939d085
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x9939d085))
data.write(b'\x1f\x83\xd3P') # 0x1f83d350
data.write(b'\x00\x10') # size
self.material_color.to_stream(data)
data.write(b'\xf60\xb8\x9f') # 0xf630b89f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_killed))
data.write(b'\x8aj\xb19') # 0x8a6ab139
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_radius))
data.write(b'\xfeD\xb7\xa4') # 0xfe44b7a4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.respawn_wait_time))
data.write(b'\x94-o*') # 0x942d6f2a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.respawn_fade_time))
data.write(b'[\xa8bE') # 0x5ba86245
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_effect0))
data.write(b'\xa8#/\xb1') # 0xa8232fb1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect0_count))
data.write(b'#\xd5{\xb1') # 0x23d57bb1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.death_effect0_scale))
data.write(b'\x90\xf4\xb1\xe0') # 0x90f4b1e0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_effect1))
data.write(b'\xbfX;\xf2') # 0xbf583bf2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect1_count))
data.write(b'\xe2[\xa4q') # 0xe25ba471
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.death_effect1_scale))
data.write(b'\x16`\xc3N') # 0x1660c34e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_effect2))
data.write(b'\x86\xd5\x077') # 0x86d50737
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect2_count))
data.write(b'{\xb9\xc2p') # 0x7bb9c270
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.death_effect2_scale))
data.write(b'\xdd<\x10\xeb') # 0xdd3c10eb
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_effect3))
data.write(b'\x91\xae\x13t') # 0x91ae1374
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect3_count))
data.write(b'\xba7\x1d\xb0') # 0xba371db0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.death_effect3_scale))
data.write(b'\xc7\xc3\xf6\x10') # 0xc7c3f610
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.death_sound))
data.write(b'\x05\xc7\x95`') # 0x5c79560
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.looped_sound))
data.write(b'\xd7\xbc\xe5\xda') # 0xd7bce5da
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd7bce5da))
data.write(b'\xe8\xb7\xe3.') # 0xe8b7e32e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe8b7e32e))
data.write(b'\xc3 \xa0P') # 0xc320a050
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc320a050))
data.write(b'\xcdL\x81\xa1') # 0xcd4c81a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcd4c81a1))
data.write(b'\r\x9cg\x15') # 0xd9c6715
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.aggression_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']),
fish_model=data['fish_model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
fish_count=data['fish_count'],
fish_scale=data['fish_scale'],
speed=data['speed'],
maximum_turn_angle=data['maximum_turn_angle'],
influence_distance=data['influence_distance'],
unknown_0x61959f0d=data['unknown_0x61959f0d'],
alignment_priority=data['alignment_priority'],
separation_priority=data['separation_priority'],
projectile_priority=data['projectile_priority'],
player_priority=data['player_priority'],
containment_priority=data['containment_priority'],
wander_priority=data['wander_priority'],
wander_amount=data['wander_amount'],
player_ball_priority=data['player_ball_priority'],
player_ball_distance=data['player_ball_distance'],
projectile_decay_rate=data['projectile_decay_rate'],
player_decay_rate=data['player_decay_rate'],
look_ahead_time=data['look_ahead_time'],
update_frame=data['update_frame'],
unknown_0x9939d085=data['unknown_0x9939d085'],
material_color=Color.from_json(data['material_color']),
can_be_killed=data['can_be_killed'],
collision_radius=data['collision_radius'],
respawn_wait_time=data['respawn_wait_time'],
respawn_fade_time=data['respawn_fade_time'],
death_effect0=data['death_effect0'],
death_effect0_count=data['death_effect0_count'],
death_effect0_scale=data['death_effect0_scale'],
death_effect1=data['death_effect1'],
death_effect1_count=data['death_effect1_count'],
death_effect1_scale=data['death_effect1_scale'],
death_effect2=data['death_effect2'],
death_effect2_count=data['death_effect2_count'],
death_effect2_scale=data['death_effect2_scale'],
death_effect3=data['death_effect3'],
death_effect3_count=data['death_effect3_count'],
death_effect3_scale=data['death_effect3_scale'],
death_sound=data['death_sound'],
looped_sound=data['looped_sound'],
unknown_0xd7bce5da=data['unknown_0xd7bce5da'],
unknown_0xe8b7e32e=data['unknown_0xe8b7e32e'],
unknown_0xc320a050=data['unknown_0xc320a050'],
unknown_0xcd4c81a1=data['unknown_0xcd4c81a1'],
aggression_data=FishCloudAggressionData.from_json(data['aggression_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'fish_model': self.fish_model,
'character_animation_information': self.character_animation_information.to_json(),
'fish_count': self.fish_count,
'fish_scale': self.fish_scale,
'speed': self.speed,
'maximum_turn_angle': self.maximum_turn_angle,
'influence_distance': self.influence_distance,
'unknown_0x61959f0d': self.unknown_0x61959f0d,
'alignment_priority': self.alignment_priority,
'separation_priority': self.separation_priority,
'projectile_priority': self.projectile_priority,
'player_priority': self.player_priority,
'containment_priority': self.containment_priority,
'wander_priority': self.wander_priority,
'wander_amount': self.wander_amount,
'player_ball_priority': self.player_ball_priority,
'player_ball_distance': self.player_ball_distance,
'projectile_decay_rate': self.projectile_decay_rate,
'player_decay_rate': self.player_decay_rate,
'look_ahead_time': self.look_ahead_time,
'update_frame': self.update_frame,
'unknown_0x9939d085': self.unknown_0x9939d085,
'material_color': self.material_color.to_json(),
'can_be_killed': self.can_be_killed,
'collision_radius': self.collision_radius,
'respawn_wait_time': self.respawn_wait_time,
'respawn_fade_time': self.respawn_fade_time,
'death_effect0': self.death_effect0,
'death_effect0_count': self.death_effect0_count,
'death_effect0_scale': self.death_effect0_scale,
'death_effect1': self.death_effect1,
'death_effect1_count': self.death_effect1_count,
'death_effect1_scale': self.death_effect1_scale,
'death_effect2': self.death_effect2,
'death_effect2_count': self.death_effect2_count,
'death_effect2_scale': self.death_effect2_scale,
'death_effect3': self.death_effect3,
'death_effect3_count': self.death_effect3_count,
'death_effect3_scale': self.death_effect3_scale,
'death_sound': self.death_sound,
'looped_sound': self.looped_sound,
'unknown_0xd7bce5da': self.unknown_0xd7bce5da,
'unknown_0xe8b7e32e': self.unknown_0xe8b7e32e,
'unknown_0xc320a050': self.unknown_0xc320a050,
'unknown_0xcd4c81a1': self.unknown_0xcd4c81a1,
'aggression_data': self.aggression_data.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_fish_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_fish_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fish_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_turn_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_influence_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x61959f0d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alignment_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_separation_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_containment_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wander_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wander_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_ball_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_ball_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_decay_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_decay_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_ahead_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_update_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x9939d085(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_material_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_can_be_killed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_collision_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_respawn_wait_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_respawn_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_effect0(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_death_effect0_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect0_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_effect1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_death_effect1_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect1_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_effect2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_death_effect2_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect2_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_effect3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_death_effect3_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect3_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_looped_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xd7bce5da(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe8b7e32e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc320a050(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xcd4c81a1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_aggression_data(data: typing.BinaryIO, property_size: int):
return FishCloudAggressionData.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),
0x7990a3b6: ('fish_model', _decode_fish_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x2264062e: ('fish_count', _decode_fish_count),
0x97beff4f: ('fish_scale', _decode_fish_scale),
0x6392404e: ('speed', _decode_speed),
0xcbab54c1: ('maximum_turn_angle', _decode_maximum_turn_angle),
0x7864ad0e: ('influence_distance', _decode_influence_distance),
0x61959f0d: ('unknown_0x61959f0d', _decode_unknown_0x61959f0d),
0x4841f1de: ('alignment_priority', _decode_alignment_priority),
0xd293ebc4: ('separation_priority', _decode_separation_priority),
0x5f362a14: ('projectile_priority', _decode_projectile_priority),
0xec9b73c2: ('player_priority', _decode_player_priority),
0x7ff1469e: ('containment_priority', _decode_containment_priority),
0x7ce17870: ('wander_priority', _decode_wander_priority),
0x3a25f09d: ('wander_amount', _decode_wander_amount),
0x23a160f3: ('player_ball_priority', _decode_player_ball_priority),
0xf0671410: ('player_ball_distance', _decode_player_ball_distance),
0xa1747268: ('projectile_decay_rate', _decode_projectile_decay_rate),
0xce77a8d0: ('player_decay_rate', _decode_player_decay_rate),
0x8cb20c53: ('look_ahead_time', _decode_look_ahead_time),
0x21b3d07c: ('update_frame', _decode_update_frame),
0x9939d085: ('unknown_0x9939d085', _decode_unknown_0x9939d085),
0x1f83d350: ('material_color', _decode_material_color),
0xf630b89f: ('can_be_killed', _decode_can_be_killed),
0x8a6ab139: ('collision_radius', _decode_collision_radius),
0xfe44b7a4: ('respawn_wait_time', _decode_respawn_wait_time),
0x942d6f2a: ('respawn_fade_time', _decode_respawn_fade_time),
0x5ba86245: ('death_effect0', _decode_death_effect0),
0xa8232fb1: ('death_effect0_count', _decode_death_effect0_count),
0x23d57bb1: ('death_effect0_scale', _decode_death_effect0_scale),
0x90f4b1e0: ('death_effect1', _decode_death_effect1),
0xbf583bf2: ('death_effect1_count', _decode_death_effect1_count),
0xe25ba471: ('death_effect1_scale', _decode_death_effect1_scale),
0x1660c34e: ('death_effect2', _decode_death_effect2),
0x86d50737: ('death_effect2_count', _decode_death_effect2_count),
0x7bb9c270: ('death_effect2_scale', _decode_death_effect2_scale),
0xdd3c10eb: ('death_effect3', _decode_death_effect3),
0x91ae1374: ('death_effect3_count', _decode_death_effect3_count),
0xba371db0: ('death_effect3_scale', _decode_death_effect3_scale),
0xc7c3f610: ('death_sound', _decode_death_sound),
0x5c79560: ('looped_sound', _decode_looped_sound),
0xd7bce5da: ('unknown_0xd7bce5da', _decode_unknown_0xd7bce5da),
0xe8b7e32e: ('unknown_0xe8b7e32e', _decode_unknown_0xe8b7e32e),
0xc320a050: ('unknown_0xc320a050', _decode_unknown_0xc320a050),
0xcd4c81a1: ('unknown_0xcd4c81a1', _decode_unknown_0xcd4c81a1),
0xd9c6715: ('aggression_data', _decode_aggression_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FishCloud.py | 0.671794 | 0.156911 | FishCloud.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.corruption as enums
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
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 ShipCommandIcon(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0x11234a3f: bool = dataclasses.field(default=False)
unknown_0x4b198e71: bool = dataclasses.field(default=False)
scannable: bool = dataclasses.field(default=True)
function: int = dataclasses.field(default=0)
disabled_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
category_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
specific_function_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
disabled_animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
category_animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
function_animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
necessary_upgrade: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
unknown_0x48ef8ade: int = dataclasses.field(default=4050431932) # Choice
unknown_0x69a7e62c: float = dataclasses.field(default=1.5)
scan_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
executing_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
missile_empty: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.CORRUPTION
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 'SHCI'
@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'\x11#J?') # 0x11234a3f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x11234a3f))
data.write(b'K\x19\x8eq') # 0x4b198e71
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4b198e71))
data.write(b'\x8b\x9bXL') # 0x8b9b584c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scannable))
data.write(b'\x95\xf8\xd6D') # 0x95f8d644
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.function))
data.write(b'\xc3\x9f\x896') # 0xc39f8936
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.disabled_texture))
data.write(b'",\xf8\xec') # 0x222cf8ec
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.category_texture))
data.write(b'\x0b\xf0\x0e\xb1') # 0xbf00eb1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.specific_function_texture))
data.write(b'm\x10\xc9\x87') # 0x6d10c987
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.disabled_animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x97\xad\xb1\x94') # 0x97adb194
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.category_animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7\x97g\x9c') # 0xa797679c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.function_animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x08\x07-\xa5') # 0x8072da5
data.write(b'\x00\x04') # size
self.necessary_upgrade.to_stream(data)
data.write(b'H\xef\x8a\xde') # 0x48ef8ade
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x48ef8ade))
data.write(b'i\xa7\xe6,') # 0x69a7e62c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x69a7e62c))
data.write(b'\xcejx\xc8') # 0xce6a78c8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.scan_sound))
data.write(b'QT`\xac') # 0x515460ac
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.executing_sound))
data.write(b'\x10(\x98\x04') # 0x10289804
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.missile_empty))
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_0x11234a3f=data['unknown_0x11234a3f'],
unknown_0x4b198e71=data['unknown_0x4b198e71'],
scannable=data['scannable'],
function=data['function'],
disabled_texture=data['disabled_texture'],
category_texture=data['category_texture'],
specific_function_texture=data['specific_function_texture'],
disabled_animation=AnimationParameters.from_json(data['disabled_animation']),
category_animation=AnimationParameters.from_json(data['category_animation']),
function_animation=AnimationParameters.from_json(data['function_animation']),
necessary_upgrade=enums.PlayerItem.from_json(data['necessary_upgrade']),
unknown_0x48ef8ade=data['unknown_0x48ef8ade'],
unknown_0x69a7e62c=data['unknown_0x69a7e62c'],
scan_sound=data['scan_sound'],
executing_sound=data['executing_sound'],
missile_empty=data['missile_empty'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0x11234a3f': self.unknown_0x11234a3f,
'unknown_0x4b198e71': self.unknown_0x4b198e71,
'scannable': self.scannable,
'function': self.function,
'disabled_texture': self.disabled_texture,
'category_texture': self.category_texture,
'specific_function_texture': self.specific_function_texture,
'disabled_animation': self.disabled_animation.to_json(),
'category_animation': self.category_animation.to_json(),
'function_animation': self.function_animation.to_json(),
'necessary_upgrade': self.necessary_upgrade.to_json(),
'unknown_0x48ef8ade': self.unknown_0x48ef8ade,
'unknown_0x69a7e62c': self.unknown_0x69a7e62c,
'scan_sound': self.scan_sound,
'executing_sound': self.executing_sound,
'missile_empty': self.missile_empty,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0x11234a3f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4b198e71(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scannable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_function(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_disabled_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_category_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_specific_function_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_disabled_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_category_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_function_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_necessary_upgrade(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_unknown_0x48ef8ade(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x69a7e62c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scan_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_executing_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_missile_empty(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),
0x11234a3f: ('unknown_0x11234a3f', _decode_unknown_0x11234a3f),
0x4b198e71: ('unknown_0x4b198e71', _decode_unknown_0x4b198e71),
0x8b9b584c: ('scannable', _decode_scannable),
0x95f8d644: ('function', _decode_function),
0xc39f8936: ('disabled_texture', _decode_disabled_texture),
0x222cf8ec: ('category_texture', _decode_category_texture),
0xbf00eb1: ('specific_function_texture', _decode_specific_function_texture),
0x6d10c987: ('disabled_animation', _decode_disabled_animation),
0x97adb194: ('category_animation', _decode_category_animation),
0xa797679c: ('function_animation', _decode_function_animation),
0x8072da5: ('necessary_upgrade', _decode_necessary_upgrade),
0x48ef8ade: ('unknown_0x48ef8ade', _decode_unknown_0x48ef8ade),
0x69a7e62c: ('unknown_0x69a7e62c', _decode_unknown_0x69a7e62c),
0xce6a78c8: ('scan_sound', _decode_scan_sound),
0x515460ac: ('executing_sound', _decode_executing_sound),
0x10289804: ('missile_empty', _decode_missile_empty),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ShipCommandIcon.py | 0.53777 | 0.246131 | ShipCommandIcon.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.