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.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class DamageActor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@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 'DMGA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage=DamageInfo.from_json(data['damage']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x337f9524: ('damage', _decode_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DamageActor.py | 0.602412 | 0.341075 | DamageActor.py | 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.ControlCommands import ControlCommands
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ControllerAction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
command: ControlCommands = dataclasses.field(default_factory=ControlCommands)
one_shot: bool = dataclasses.field(default=False)
disable_during_cinematics: bool = dataclasses.field(default=False)
auto_press_during_cinematic_skip: bool = dataclasses.field(default=False)
decay_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.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 'CNTA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'q\x0f\xe5\xd7') # 0x710fe5d7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.command.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
data.write(b')\xf4F\xfc') # 0x29f446fc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_during_cinematics))
data.write(b'\xc71\xaea') # 0xc731ae61
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_press_during_cinematic_skip))
data.write(b'\xfc\x82\x7fc') # 0xfc827f63
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.decay_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
command=ControlCommands.from_json(data['command']),
one_shot=data['one_shot'],
disable_during_cinematics=data['disable_during_cinematics'],
auto_press_during_cinematic_skip=data['auto_press_during_cinematic_skip'],
decay_time=data['decay_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'command': self.command.to_json(),
'one_shot': self.one_shot,
'disable_during_cinematics': self.disable_during_cinematics,
'auto_press_during_cinematic_skip': self.auto_press_during_cinematic_skip,
'decay_time': self.decay_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_command(data: typing.BinaryIO, property_size: int):
return ControlCommands.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_during_cinematics(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_press_during_cinematic_skip(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_decay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x710fe5d7: ('command', _decode_command),
0xead7b7bb: ('one_shot', _decode_one_shot),
0x29f446fc: ('disable_during_cinematics', _decode_disable_during_cinematics),
0xc731ae61: ('auto_press_during_cinematic_skip', _decode_auto_press_during_cinematic_skip),
0xfc827f63: ('decay_time', _decode_decay_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ControllerAction.py | 0.585338 | 0.293832 | ControllerAction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.MetroidPhazeoidData import MetroidPhazeoidData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class MetroidPhazeoid(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
metroid_phazeoid_data: MetroidPhazeoidData = dataclasses.field(default_factory=MetroidPhazeoidData)
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 'MPHZ'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_MetroidPhazeoid.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'\xe5\x8aA\x13') # 0xe58a4113
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.metroid_phazeoid_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})
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']),
metroid_phazeoid_data=MetroidPhazeoidData.from_json(data['metroid_phazeoid_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(),
'metroid_phazeoid_data': self.metroid_phazeoid_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_metroid_phazeoid_data(data: typing.BinaryIO, property_size: int):
return MetroidPhazeoidData.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})
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),
0xe58a4113: ('metroid_phazeoid_data', _decode_metroid_phazeoid_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/MetroidPhazeoid.py | 0.621885 | 0.351951 | MetroidPhazeoid.py | 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.ShipDecalControllerStruct import ShipDecalControllerStruct
@dataclasses.dataclass()
class ShipDecalController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
ship_decal_controller_struct_0x15fbdf30: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0x59b4b241: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xb663308d: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0x7640ad4c: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0x9b6ede52: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xea024af3: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xa3b7ee26: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xc7b1dd81: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xd7c6638e: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0x124974e5: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xf8cfa987: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xa77487d5: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
ship_decal_controller_struct_0xe590a13e: ShipDecalControllerStruct = dataclasses.field(default_factory=ShipDecalControllerStruct)
@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 'SPDC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x15\xfb\xdf0') # 0x15fbdf30
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0x15fbdf30.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Y\xb4\xb2A') # 0x59b4b241
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0x59b4b241.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6c0\x8d') # 0xb663308d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xb663308d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v@\xadL') # 0x7640ad4c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0x7640ad4c.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9bn\xdeR') # 0x9b6ede52
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0x9b6ede52.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\x02J\xf3') # 0xea024af3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xea024af3.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa3\xb7\xee&') # 0xa3b7ee26
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xa3b7ee26.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc7\xb1\xdd\x81') # 0xc7b1dd81
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xc7b1dd81.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd7\xc6c\x8e') # 0xd7c6638e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xd7c6638e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12It\xe5') # 0x124974e5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0x124974e5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf8\xcf\xa9\x87') # 0xf8cfa987
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xf8cfa987.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7t\x87\xd5') # 0xa77487d5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xa77487d5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe5\x90\xa1>') # 0xe590a13e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_decal_controller_struct_0xe590a13e.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']),
ship_decal_controller_struct_0x15fbdf30=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0x15fbdf30']),
ship_decal_controller_struct_0x59b4b241=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0x59b4b241']),
ship_decal_controller_struct_0xb663308d=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xb663308d']),
ship_decal_controller_struct_0x7640ad4c=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0x7640ad4c']),
ship_decal_controller_struct_0x9b6ede52=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0x9b6ede52']),
ship_decal_controller_struct_0xea024af3=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xea024af3']),
ship_decal_controller_struct_0xa3b7ee26=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xa3b7ee26']),
ship_decal_controller_struct_0xc7b1dd81=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xc7b1dd81']),
ship_decal_controller_struct_0xd7c6638e=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xd7c6638e']),
ship_decal_controller_struct_0x124974e5=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0x124974e5']),
ship_decal_controller_struct_0xf8cfa987=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xf8cfa987']),
ship_decal_controller_struct_0xa77487d5=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xa77487d5']),
ship_decal_controller_struct_0xe590a13e=ShipDecalControllerStruct.from_json(data['ship_decal_controller_struct_0xe590a13e']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'ship_decal_controller_struct_0x15fbdf30': self.ship_decal_controller_struct_0x15fbdf30.to_json(),
'ship_decal_controller_struct_0x59b4b241': self.ship_decal_controller_struct_0x59b4b241.to_json(),
'ship_decal_controller_struct_0xb663308d': self.ship_decal_controller_struct_0xb663308d.to_json(),
'ship_decal_controller_struct_0x7640ad4c': self.ship_decal_controller_struct_0x7640ad4c.to_json(),
'ship_decal_controller_struct_0x9b6ede52': self.ship_decal_controller_struct_0x9b6ede52.to_json(),
'ship_decal_controller_struct_0xea024af3': self.ship_decal_controller_struct_0xea024af3.to_json(),
'ship_decal_controller_struct_0xa3b7ee26': self.ship_decal_controller_struct_0xa3b7ee26.to_json(),
'ship_decal_controller_struct_0xc7b1dd81': self.ship_decal_controller_struct_0xc7b1dd81.to_json(),
'ship_decal_controller_struct_0xd7c6638e': self.ship_decal_controller_struct_0xd7c6638e.to_json(),
'ship_decal_controller_struct_0x124974e5': self.ship_decal_controller_struct_0x124974e5.to_json(),
'ship_decal_controller_struct_0xf8cfa987': self.ship_decal_controller_struct_0xf8cfa987.to_json(),
'ship_decal_controller_struct_0xa77487d5': self.ship_decal_controller_struct_0xa77487d5.to_json(),
'ship_decal_controller_struct_0xe590a13e': self.ship_decal_controller_struct_0xe590a13e.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0x15fbdf30(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0x59b4b241(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xb663308d(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0x7640ad4c(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0x9b6ede52(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xea024af3(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xa3b7ee26(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xc7b1dd81(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xd7c6638e(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0x124974e5(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xf8cfa987(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xa77487d5(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.from_stream(data, property_size)
def _decode_ship_decal_controller_struct_0xe590a13e(data: typing.BinaryIO, property_size: int):
return ShipDecalControllerStruct.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),
0x15fbdf30: ('ship_decal_controller_struct_0x15fbdf30', _decode_ship_decal_controller_struct_0x15fbdf30),
0x59b4b241: ('ship_decal_controller_struct_0x59b4b241', _decode_ship_decal_controller_struct_0x59b4b241),
0xb663308d: ('ship_decal_controller_struct_0xb663308d', _decode_ship_decal_controller_struct_0xb663308d),
0x7640ad4c: ('ship_decal_controller_struct_0x7640ad4c', _decode_ship_decal_controller_struct_0x7640ad4c),
0x9b6ede52: ('ship_decal_controller_struct_0x9b6ede52', _decode_ship_decal_controller_struct_0x9b6ede52),
0xea024af3: ('ship_decal_controller_struct_0xea024af3', _decode_ship_decal_controller_struct_0xea024af3),
0xa3b7ee26: ('ship_decal_controller_struct_0xa3b7ee26', _decode_ship_decal_controller_struct_0xa3b7ee26),
0xc7b1dd81: ('ship_decal_controller_struct_0xc7b1dd81', _decode_ship_decal_controller_struct_0xc7b1dd81),
0xd7c6638e: ('ship_decal_controller_struct_0xd7c6638e', _decode_ship_decal_controller_struct_0xd7c6638e),
0x124974e5: ('ship_decal_controller_struct_0x124974e5', _decode_ship_decal_controller_struct_0x124974e5),
0xf8cfa987: ('ship_decal_controller_struct_0xf8cfa987', _decode_ship_decal_controller_struct_0xf8cfa987),
0xa77487d5: ('ship_decal_controller_struct_0xa77487d5', _decode_ship_decal_controller_struct_0xa77487d5),
0xe590a13e: ('ship_decal_controller_struct_0xe590a13e', _decode_ship_decal_controller_struct_0xe590a13e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ShipDecalController.py | 0.490968 | 0.215826 | ShipDecalController.py | 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 VisorGoo(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
electric: AssetId = dataclasses.field(metadata={'asset_types': ['ELSC']}, default=default_asset_id)
min_range: float = dataclasses.field(default=1.0)
max_range: float = dataclasses.field(default=8.0)
unknown_0x4538fdc7: float = dataclasses.field(default=40.0)
unknown_0x057785b1: float = dataclasses.field(default=20.0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
sound_hit_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
no_view_check: bool = dataclasses.field(default=False)
persistent: bool = dataclasses.field(default=False)
unknown_0xcb9a3009: 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 'VGOO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'm\x1c\xe5%') # 0x6d1ce525
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle))
data.write(b'q\xdb\xe2\xf2') # 0x71dbe2f2
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.electric))
data.write(b'\x97D\x97\x1e') # 0x9744971e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_range))
data.write(b'\xd7\x0b\xefh') # 0xd70bef68
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_range))
data.write(b'E8\xfd\xc7') # 0x4538fdc7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4538fdc7))
data.write(b'\x05w\x85\xb1') # 0x57785b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x057785b1))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\\\xfd\x03J') # 0x5cfd034a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_hit_sound))
data.write(b'\xd5\xb7\x8b\xc9') # 0xd5b78bc9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_view_check))
data.write(b'\xea\x03\xe2X') # 0xea03e258
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.persistent))
data.write(b'\xcb\x9a0\t') # 0xcb9a3009
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcb9a3009))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
particle=data['particle'],
electric=data['electric'],
min_range=data['min_range'],
max_range=data['max_range'],
unknown_0x4538fdc7=data['unknown_0x4538fdc7'],
unknown_0x057785b1=data['unknown_0x057785b1'],
color=Color.from_json(data['color']),
sound_hit_sound=data['sound_hit_sound'],
no_view_check=data['no_view_check'],
persistent=data['persistent'],
unknown_0xcb9a3009=data['unknown_0xcb9a3009'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'particle': self.particle,
'electric': self.electric,
'min_range': self.min_range,
'max_range': self.max_range,
'unknown_0x4538fdc7': self.unknown_0x4538fdc7,
'unknown_0x057785b1': self.unknown_0x057785b1,
'color': self.color.to_json(),
'sound_hit_sound': self.sound_hit_sound,
'no_view_check': self.no_view_check,
'persistent': self.persistent,
'unknown_0xcb9a3009': self.unknown_0xcb9a3009,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_particle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_electric(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_min_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4538fdc7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x057785b1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_sound_hit_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_no_view_check(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_persistent(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xcb9a3009(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),
0x6d1ce525: ('particle', _decode_particle),
0x71dbe2f2: ('electric', _decode_electric),
0x9744971e: ('min_range', _decode_min_range),
0xd70bef68: ('max_range', _decode_max_range),
0x4538fdc7: ('unknown_0x4538fdc7', _decode_unknown_0x4538fdc7),
0x57785b1: ('unknown_0x057785b1', _decode_unknown_0x057785b1),
0x37c7d09d: ('color', _decode_color),
0x5cfd034a: ('sound_hit_sound', _decode_sound_hit_sound),
0xd5b78bc9: ('no_view_check', _decode_no_view_check),
0xea03e258: ('persistent', _decode_persistent),
0xcb9a3009: ('unknown_0xcb9a3009', _decode_unknown_0xcb9a3009),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/VisorGoo.py | 0.577972 | 0.288043 | VisorGoo.py | 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.DarkSamusEchoData import DarkSamusEchoData
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class DarkSamusEcho(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
dark_samus_echo_data_0x6d8a6608: DarkSamusEchoData = dataclasses.field(default_factory=DarkSamusEchoData)
dark_samus_echo_data_0x35c49ddd: DarkSamusEchoData = dataclasses.field(default_factory=DarkSamusEchoData)
dark_samus_echo_data_0xa1178bcf: DarkSamusEchoData = dataclasses.field(default_factory=DarkSamusEchoData)
@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 'DKSE'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_DarkSamusEcho.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'm\x8af\x08') # 0x6d8a6608
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_samus_echo_data_0x6d8a6608.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'5\xc4\x9d\xdd') # 0x35c49ddd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_samus_echo_data_0x35c49ddd.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa1\x17\x8b\xcf') # 0xa1178bcf
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_samus_echo_data_0xa1178bcf.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']),
dark_samus_echo_data_0x6d8a6608=DarkSamusEchoData.from_json(data['dark_samus_echo_data_0x6d8a6608']),
dark_samus_echo_data_0x35c49ddd=DarkSamusEchoData.from_json(data['dark_samus_echo_data_0x35c49ddd']),
dark_samus_echo_data_0xa1178bcf=DarkSamusEchoData.from_json(data['dark_samus_echo_data_0xa1178bcf']),
)
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(),
'dark_samus_echo_data_0x6d8a6608': self.dark_samus_echo_data_0x6d8a6608.to_json(),
'dark_samus_echo_data_0x35c49ddd': self.dark_samus_echo_data_0x35c49ddd.to_json(),
'dark_samus_echo_data_0xa1178bcf': self.dark_samus_echo_data_0xa1178bcf.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_dark_samus_echo_data_0x6d8a6608(data: typing.BinaryIO, property_size: int):
return DarkSamusEchoData.from_stream(data, property_size)
def _decode_dark_samus_echo_data_0x35c49ddd(data: typing.BinaryIO, property_size: int):
return DarkSamusEchoData.from_stream(data, property_size)
def _decode_dark_samus_echo_data_0xa1178bcf(data: typing.BinaryIO, property_size: int):
return DarkSamusEchoData.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),
0x6d8a6608: ('dark_samus_echo_data_0x6d8a6608', _decode_dark_samus_echo_data_0x6d8a6608),
0x35c49ddd: ('dark_samus_echo_data_0x35c49ddd', _decode_dark_samus_echo_data_0x35c49ddd),
0xa1178bcf: ('dark_samus_echo_data_0xa1178bcf', _decode_dark_samus_echo_data_0xa1178bcf),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DarkSamusEcho.py | 0.574037 | 0.302069 | DarkSamusEcho.py | 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.DamageInfo import DamageInfo
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.RainProperties import RainProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class AreaAttributes(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
need_sky: bool = dataclasses.field(default=False)
environment_effects: enums.EnvironmentEffects = dataclasses.field(default=enums.EnvironmentEffects.Unknown1)
rain_properties: RainProperties = dataclasses.field(default_factory=RainProperties)
environment_group_sound: int = dataclasses.field(default=0, metadata={'sound': True})
density: float = dataclasses.field(default=1.0)
normal_lighting: float = dataclasses.field(default=1.0)
unknown_0x6dade808: float = dataclasses.field(default=42.0)
override_sky: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
use_override_sky: bool = dataclasses.field(default=True)
unknown_0xe3426206: bool = dataclasses.field(default=False)
phazon_damage: enums.PhazonDamage = dataclasses.field(default=enums.PhazonDamage.Unknown1)
unknown_0x07b26bf9: bool = dataclasses.field(default=True)
unknown_0x46cc1b48: bool = dataclasses.field(default=False)
damage_spline: Spline = dataclasses.field(default_factory=Spline)
environment_damage_info: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@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 'REAA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x95\xd4\xbe\xe7') # 0x95d4bee7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.need_sky))
data.write(b"\xea'\x00\xe9") # 0xea2700e9
data.write(b'\x00\x04') # size
self.environment_effects.to_stream(data)
data.write(b'\xce\x03(\xfa') # 0xce0328fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rain_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&>5') # 0x56263e35
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.environment_group_sound))
data.write(b'd\xe5\xfe\x9f') # 0x64e5fe9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.density))
data.write(b'\xba_\x80\x1e') # 0xba5f801e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.normal_lighting))
data.write(b'm\xad\xe8\x08') # 0x6dade808
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6dade808))
data.write(b'\xd2\x08\xc9\xfa') # 0xd208c9fa
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.override_sky))
data.write(b')DS\x02') # 0x29445302
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_override_sky))
data.write(b'\xe3Bb\x06') # 0xe3426206
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe3426206))
data.write(b'N\x08\xb9\x84') # 0x4e08b984
data.write(b'\x00\x04') # size
self.phazon_damage.to_stream(data)
data.write(b'\x07\xb2k\xf9') # 0x7b26bf9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x07b26bf9))
data.write(b'F\xcc\x1bH') # 0x46cc1b48
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x46cc1b48))
data.write(b'\xfa\x87:g') # 0xfa873a67
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\xa0\xe6\x9b') # 0xe7a0e69b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.environment_damage_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']),
need_sky=data['need_sky'],
environment_effects=enums.EnvironmentEffects.from_json(data['environment_effects']),
rain_properties=RainProperties.from_json(data['rain_properties']),
environment_group_sound=data['environment_group_sound'],
density=data['density'],
normal_lighting=data['normal_lighting'],
unknown_0x6dade808=data['unknown_0x6dade808'],
override_sky=data['override_sky'],
use_override_sky=data['use_override_sky'],
unknown_0xe3426206=data['unknown_0xe3426206'],
phazon_damage=enums.PhazonDamage.from_json(data['phazon_damage']),
unknown_0x07b26bf9=data['unknown_0x07b26bf9'],
unknown_0x46cc1b48=data['unknown_0x46cc1b48'],
damage_spline=Spline.from_json(data['damage_spline']),
environment_damage_info=DamageInfo.from_json(data['environment_damage_info']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'need_sky': self.need_sky,
'environment_effects': self.environment_effects.to_json(),
'rain_properties': self.rain_properties.to_json(),
'environment_group_sound': self.environment_group_sound,
'density': self.density,
'normal_lighting': self.normal_lighting,
'unknown_0x6dade808': self.unknown_0x6dade808,
'override_sky': self.override_sky,
'use_override_sky': self.use_override_sky,
'unknown_0xe3426206': self.unknown_0xe3426206,
'phazon_damage': self.phazon_damage.to_json(),
'unknown_0x07b26bf9': self.unknown_0x07b26bf9,
'unknown_0x46cc1b48': self.unknown_0x46cc1b48,
'damage_spline': self.damage_spline.to_json(),
'environment_damage_info': self.environment_damage_info.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_need_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_environment_effects(data: typing.BinaryIO, property_size: int):
return enums.EnvironmentEffects.from_stream(data)
def _decode_rain_properties(data: typing.BinaryIO, property_size: int):
return RainProperties.from_stream(data, property_size)
def _decode_environment_group_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_normal_lighting(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6dade808(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_override_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_use_override_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe3426206(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_phazon_damage(data: typing.BinaryIO, property_size: int):
return enums.PhazonDamage.from_stream(data)
def _decode_unknown_0x07b26bf9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x46cc1b48(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_damage_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_environment_damage_info(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x95d4bee7: ('need_sky', _decode_need_sky),
0xea2700e9: ('environment_effects', _decode_environment_effects),
0xce0328fa: ('rain_properties', _decode_rain_properties),
0x56263e35: ('environment_group_sound', _decode_environment_group_sound),
0x64e5fe9f: ('density', _decode_density),
0xba5f801e: ('normal_lighting', _decode_normal_lighting),
0x6dade808: ('unknown_0x6dade808', _decode_unknown_0x6dade808),
0xd208c9fa: ('override_sky', _decode_override_sky),
0x29445302: ('use_override_sky', _decode_use_override_sky),
0xe3426206: ('unknown_0xe3426206', _decode_unknown_0xe3426206),
0x4e08b984: ('phazon_damage', _decode_phazon_damage),
0x7b26bf9: ('unknown_0x07b26bf9', _decode_unknown_0x07b26bf9),
0x46cc1b48: ('unknown_0x46cc1b48', _decode_unknown_0x46cc1b48),
0xfa873a67: ('damage_spline', _decode_damage_spline),
0xe7a0e69b: ('environment_damage_info', _decode_environment_damage_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AreaAttributes.py | 0.550124 | 0.255675 | AreaAttributes.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class CameraPitch(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
forwards_pitch: Spline = dataclasses.field(default_factory=Spline)
backwards_pitch: Spline = dataclasses.field(default_factory=Spline)
use_player_radius: bool = dataclasses.field(default=False)
max_radius: float = dataclasses.field(default=20.0)
ease_in: Spline = dataclasses.field(default_factory=Spline)
ease_out: 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 'CAMP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x81\xd0\x93\xb3') # 0x81d093b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.forwards_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xad\x9f\x8e>') # 0xad9f8e3e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.backwards_pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'9"\xd9\xdc') # 0x3922d9dc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_player_radius))
data.write(b'\xc5\x99\xbc\xbb') # 0xc599bcbb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_radius))
data.write(b'\xdfUP\xcc') # 0xdf5550cc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ease_in.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcaX\x134') # 0xca581334
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ease_out.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']),
forwards_pitch=Spline.from_json(data['forwards_pitch']),
backwards_pitch=Spline.from_json(data['backwards_pitch']),
use_player_radius=data['use_player_radius'],
max_radius=data['max_radius'],
ease_in=Spline.from_json(data['ease_in']),
ease_out=Spline.from_json(data['ease_out']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'forwards_pitch': self.forwards_pitch.to_json(),
'backwards_pitch': self.backwards_pitch.to_json(),
'use_player_radius': self.use_player_radius,
'max_radius': self.max_radius,
'ease_in': self.ease_in.to_json(),
'ease_out': self.ease_out.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_forwards_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_backwards_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_use_player_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_max_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ease_in(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_ease_out(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),
0x81d093b3: ('forwards_pitch', _decode_forwards_pitch),
0xad9f8e3e: ('backwards_pitch', _decode_backwards_pitch),
0x3922d9dc: ('use_player_radius', _decode_use_player_radius),
0xc599bcbb: ('max_radius', _decode_max_radius),
0xdf5550cc: ('ease_in', _decode_ease_in),
0xca581334: ('ease_out', _decode_ease_out),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CameraPitch.py | 0.633864 | 0.310198 | CameraPitch.py | 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 Dock(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
dock_number: int = dataclasses.field(default=0)
area_number: int = dataclasses.field(default=0)
is_virtual: bool = dataclasses.field(default=False)
load_connected_immediate: bool = dataclasses.field(default=True)
show_soft_transition: 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 'DOCK'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x11\x01\xe9\x1b') # 0x1101e91b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.dock_number))
data.write(b'a\x0e\xec\x90') # 0x610eec90
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.area_number))
data.write(b'\x87\x0emo') # 0x870e6d6f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_virtual))
data.write(b'\xf3\x83\x9do') # 0xf3839d6f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.load_connected_immediate))
data.write(b'"-\x9d\xaf') # 0x222d9daf
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.show_soft_transition))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
dock_number=data['dock_number'],
area_number=data['area_number'],
is_virtual=data['is_virtual'],
load_connected_immediate=data['load_connected_immediate'],
show_soft_transition=data['show_soft_transition'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'dock_number': self.dock_number,
'area_number': self.area_number,
'is_virtual': self.is_virtual,
'load_connected_immediate': self.load_connected_immediate,
'show_soft_transition': self.show_soft_transition,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_dock_number(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_area_number(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_virtual(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_load_connected_immediate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_show_soft_transition(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),
0x1101e91b: ('dock_number', _decode_dock_number),
0x610eec90: ('area_number', _decode_area_number),
0x870e6d6f: ('is_virtual', _decode_is_virtual),
0xf3839d6f: ('load_connected_immediate', _decode_load_connected_immediate),
0x222d9daf: ('show_soft_transition', _decode_show_soft_transition),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Dock.py | 0.605566 | 0.346624 | Dock.py | 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.FluidProperties import FluidProperties
from retro_data_structures.properties.corruption.archetypes.TriggerInfo import TriggerInfo
@dataclasses.dataclass()
class Water(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger_properties: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
fluid_properties: FluidProperties = dataclasses.field(default_factory=FluidProperties)
@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 'WATR'
@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'\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"'M\x1eT") # 0x274d1e54
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fluid_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']),
trigger_properties=TriggerInfo.from_json(data['trigger_properties']),
fluid_properties=FluidProperties.from_json(data['fluid_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger_properties': self.trigger_properties.to_json(),
'fluid_properties': self.fluid_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger_properties(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_fluid_properties(data: typing.BinaryIO, property_size: int):
return FluidProperties.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),
0xbbfee93e: ('trigger_properties', _decode_trigger_properties),
0x274d1e54: ('fluid_properties', _decode_fluid_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Water.py | 0.637144 | 0.319227 | Water.py | 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 LUAScript(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
abandoned_world: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
phaaze_world: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
unknown_0xed4a2787: str = dataclasses.field(default='')
unknown_0x9facea01: str = dataclasses.field(default='')
unknown_0xea46b664: str = dataclasses.field(default='')
unknown_0xa1ecc54b: str = dataclasses.field(default='')
@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 'LUAX'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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)
if self.abandoned_world != default_override.get('abandoned_world', default_asset_id):
num_properties_written += 1
data.write(b'+\xf9\xaet') # 0x2bf9ae74
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.abandoned_world))
if self.phaaze_world != default_override.get('phaaze_world', default_asset_id):
num_properties_written += 1
data.write(b'VzH\xf4') # 0x567a48f4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.phaaze_world))
data.write(b"\xedJ'\x87") # 0xed4a2787
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xed4a2787.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'\x9f\xac\xea\x01') # 0x9facea01
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x9facea01.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'\xeaF\xb6d') # 0xea46b664
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xea46b664.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'\xa1\xec\xc5K') # 0xa1ecc54b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xa1ecc54b.encode("utf-8"))
data.write(b'\x00')
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']),
abandoned_world=data['abandoned_world'],
phaaze_world=data['phaaze_world'],
unknown_0xed4a2787=data['unknown_0xed4a2787'],
unknown_0x9facea01=data['unknown_0x9facea01'],
unknown_0xea46b664=data['unknown_0xea46b664'],
unknown_0xa1ecc54b=data['unknown_0xa1ecc54b'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'abandoned_world': self.abandoned_world,
'phaaze_world': self.phaaze_world,
'unknown_0xed4a2787': self.unknown_0xed4a2787,
'unknown_0x9facea01': self.unknown_0x9facea01,
'unknown_0xea46b664': self.unknown_0xea46b664,
'unknown_0xa1ecc54b': self.unknown_0xa1ecc54b,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_abandoned_world(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_phaaze_world(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0xed4a2787(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x9facea01(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0xea46b664(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0xa1ecc54b(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x2bf9ae74: ('abandoned_world', _decode_abandoned_world),
0x567a48f4: ('phaaze_world', _decode_phaaze_world),
0xed4a2787: ('unknown_0xed4a2787', _decode_unknown_0xed4a2787),
0x9facea01: ('unknown_0x9facea01', _decode_unknown_0x9facea01),
0xea46b664: ('unknown_0xea46b664', _decode_unknown_0xea46b664),
0xa1ecc54b: ('unknown_0xa1ecc54b', _decode_unknown_0xa1ecc54b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/LUAScript.py | 0.524882 | 0.340924 | LUAScript.py | 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 LightVolume(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
num_subdivisions: int = dataclasses.field(default=10)
@classmethod
def game(cls) -> Game:
return Game.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 'LVOL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'>\xdb\xe3r') # 0x3edbe372
data.write(b'\x00\x10') # size
self.unknown.to_stream(data)
data.write(b'~CY\xd1') # 0x7e4359d1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.num_subdivisions))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown=Color.from_json(data['unknown']),
num_subdivisions=data['num_subdivisions'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown.to_json(),
'num_subdivisions': self.num_subdivisions,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_num_subdivisions(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3edbe372: ('unknown', _decode_unknown),
0x7e4359d1: ('num_subdivisions', _decode_num_subdivisions),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/LightVolume.py | 0.622918 | 0.317664 | LightVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.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.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class AmbientAI(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
mass: float = dataclasses.field(default=1.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
detect_radius: float = dataclasses.field(default=7.0)
explode_radius: float = dataclasses.field(default=1.5)
unknown_0x6c3b5f38: int = dataclasses.field(default=0)
unknown_0xe9bf2240: 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 'AMIA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0c') # 12 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
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'\xa2D\xc9\xd8') # 0xa244c9d8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7\xd0\x07\x80') # 0xa7d00780
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detect_radius))
data.write(b'\xd4\xd5&1') # 0xd4d52631
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.explode_radius))
data.write(b'l;_8') # 0x6c3b5f38
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6c3b5f38))
data.write(b'\xe9\xbf"@') # 0xe9bf2240
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe9bf2240))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
mass=data['mass'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
detect_radius=data['detect_radius'],
explode_radius=data['explode_radius'],
unknown_0x6c3b5f38=data['unknown_0x6c3b5f38'],
unknown_0xe9bf2240=data['unknown_0xe9bf2240'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'mass': self.mass,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'character_animation_information': self.character_animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'detect_radius': self.detect_radius,
'explode_radius': self.explode_radius,
'unknown_0x6c3b5f38': self.unknown_0x6c3b5f38,
'unknown_0xe9bf2240': self.unknown_0xe9bf2240,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_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_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_detect_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_explode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6c3b5f38(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xe9bf2240(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),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x75dbb375: ('mass', _decode_mass),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa7d00780: ('detect_radius', _decode_detect_radius),
0xd4d52631: ('explode_radius', _decode_explode_radius),
0x6c3b5f38: ('unknown_0x6c3b5f38', _decode_unknown_0x6c3b5f38),
0xe9bf2240: ('unknown_0xe9bf2240', _decode_unknown_0xe9bf2240),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AmbientAI.py | 0.579757 | 0.326889 | AmbientAI.py | 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.ShipData import ShipData
@dataclasses.dataclass()
class Ship(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
ship_data: ShipData = dataclasses.field(default_factory=ShipData)
@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 'SHIP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Ship.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'\xc8T\xd4\xa6') # 0xc854d4a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship_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']),
ship_data=ShipData.from_json(data['ship_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(),
'ship_data': self.ship_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_ship_data(data: typing.BinaryIO, property_size: int):
return ShipData.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),
0xc854d4a6: ('ship_data', _decode_ship_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Ship.py | 0.643329 | 0.337285 | Ship.py | 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 AITaskPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
stay_forever: bool = dataclasses.field(default=False)
unknown_0xb553cda1: float = dataclasses.field(default=1.0)
unknown_0x53336240: float = dataclasses.field(default=30.0)
unknown_0x12341132: bool = dataclasses.field(default=False)
unknown_0xaaccd7cd: int = dataclasses.field(default=0)
idle_animation: int = dataclasses.field(default=0)
unknown_0x799f6f58: int = dataclasses.field(default=0)
unknown_0x121045f5: float = dataclasses.field(default=5.0)
unknown_0xf470ea14: float = dataclasses.field(default=10.0)
unknown_0x7aa31371: int = dataclasses.field(default=0)
unknown_0x0ac4d7ad: int = dataclasses.field(default=0)
unknown_0x03d511b9: int = dataclasses.field(default=0)
unknown_0x2bd321da: int = dataclasses.field(default=0)
unknown_0x2b3bd997: int = dataclasses.field(default=0)
unknown_0xc36101f6: int = dataclasses.field(default=0)
unknown_0x3fa8c740: int = dataclasses.field(default=0)
unknown_0x3aca31d7: int = dataclasses.field(default=0)
unknown_0xe5d4d300: int = dataclasses.field(default=8)
is_combat_task: bool = dataclasses.field(default=False)
unknown_0x2cf6f605: bool = dataclasses.field(default=False)
unknown_0x81591346: bool = dataclasses.field(default=False)
unknown_0xf874aa52: bool = dataclasses.field(default=True)
align_ai: bool = dataclasses.field(default=False)
unknown_0x2340b043: 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 'AITP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x19') # 25 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\x94\x1e\xb7') # 0x56941eb7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.stay_forever))
data.write(b'\xb5S\xcd\xa1') # 0xb553cda1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb553cda1))
data.write(b'S3b@') # 0x53336240
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x53336240))
data.write(b'\x124\x112') # 0x12341132
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x12341132))
data.write(b'\xaa\xcc\xd7\xcd') # 0xaaccd7cd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xaaccd7cd))
data.write(b'\xa2\xa5\xb3\x8f') # 0xa2a5b38f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.idle_animation))
data.write(b'y\x9foX') # 0x799f6f58
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x799f6f58))
data.write(b'\x12\x10E\xf5') # 0x121045f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x121045f5))
data.write(b'\xf4p\xea\x14') # 0xf470ea14
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf470ea14))
data.write(b'z\xa3\x13q') # 0x7aa31371
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7aa31371))
data.write(b'\n\xc4\xd7\xad') # 0xac4d7ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x0ac4d7ad))
data.write(b'\x03\xd5\x11\xb9') # 0x3d511b9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x03d511b9))
data.write(b'+\xd3!\xda') # 0x2bd321da
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2bd321da))
data.write(b'+;\xd9\x97') # 0x2b3bd997
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x2b3bd997))
data.write(b'\xc3a\x01\xf6') # 0xc36101f6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc36101f6))
data.write(b'?\xa8\xc7@') # 0x3fa8c740
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3fa8c740))
data.write(b':\xca1\xd7') # 0x3aca31d7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3aca31d7))
data.write(b'\xe5\xd4\xd3\x00') # 0xe5d4d300
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe5d4d300))
data.write(b'%(\xf4B') # 0x2528f442
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_combat_task))
data.write(b',\xf6\xf6\x05') # 0x2cf6f605
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2cf6f605))
data.write(b'\x81Y\x13F') # 0x81591346
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x81591346))
data.write(b'\xf8t\xaaR') # 0xf874aa52
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf874aa52))
data.write(b'\\ \xcfX') # 0x5c20cf58
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.align_ai))
data.write(b'#@\xb0C') # 0x2340b043
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2340b043))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
stay_forever=data['stay_forever'],
unknown_0xb553cda1=data['unknown_0xb553cda1'],
unknown_0x53336240=data['unknown_0x53336240'],
unknown_0x12341132=data['unknown_0x12341132'],
unknown_0xaaccd7cd=data['unknown_0xaaccd7cd'],
idle_animation=data['idle_animation'],
unknown_0x799f6f58=data['unknown_0x799f6f58'],
unknown_0x121045f5=data['unknown_0x121045f5'],
unknown_0xf470ea14=data['unknown_0xf470ea14'],
unknown_0x7aa31371=data['unknown_0x7aa31371'],
unknown_0x0ac4d7ad=data['unknown_0x0ac4d7ad'],
unknown_0x03d511b9=data['unknown_0x03d511b9'],
unknown_0x2bd321da=data['unknown_0x2bd321da'],
unknown_0x2b3bd997=data['unknown_0x2b3bd997'],
unknown_0xc36101f6=data['unknown_0xc36101f6'],
unknown_0x3fa8c740=data['unknown_0x3fa8c740'],
unknown_0x3aca31d7=data['unknown_0x3aca31d7'],
unknown_0xe5d4d300=data['unknown_0xe5d4d300'],
is_combat_task=data['is_combat_task'],
unknown_0x2cf6f605=data['unknown_0x2cf6f605'],
unknown_0x81591346=data['unknown_0x81591346'],
unknown_0xf874aa52=data['unknown_0xf874aa52'],
align_ai=data['align_ai'],
unknown_0x2340b043=data['unknown_0x2340b043'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'stay_forever': self.stay_forever,
'unknown_0xb553cda1': self.unknown_0xb553cda1,
'unknown_0x53336240': self.unknown_0x53336240,
'unknown_0x12341132': self.unknown_0x12341132,
'unknown_0xaaccd7cd': self.unknown_0xaaccd7cd,
'idle_animation': self.idle_animation,
'unknown_0x799f6f58': self.unknown_0x799f6f58,
'unknown_0x121045f5': self.unknown_0x121045f5,
'unknown_0xf470ea14': self.unknown_0xf470ea14,
'unknown_0x7aa31371': self.unknown_0x7aa31371,
'unknown_0x0ac4d7ad': self.unknown_0x0ac4d7ad,
'unknown_0x03d511b9': self.unknown_0x03d511b9,
'unknown_0x2bd321da': self.unknown_0x2bd321da,
'unknown_0x2b3bd997': self.unknown_0x2b3bd997,
'unknown_0xc36101f6': self.unknown_0xc36101f6,
'unknown_0x3fa8c740': self.unknown_0x3fa8c740,
'unknown_0x3aca31d7': self.unknown_0x3aca31d7,
'unknown_0xe5d4d300': self.unknown_0xe5d4d300,
'is_combat_task': self.is_combat_task,
'unknown_0x2cf6f605': self.unknown_0x2cf6f605,
'unknown_0x81591346': self.unknown_0x81591346,
'unknown_0xf874aa52': self.unknown_0xf874aa52,
'align_ai': self.align_ai,
'unknown_0x2340b043': self.unknown_0x2340b043,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_stay_forever(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb553cda1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x53336240(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x12341132(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xaaccd7cd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_idle_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x799f6f58(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x121045f5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf470ea14(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7aa31371(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x0ac4d7ad(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x03d511b9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2bd321da(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x2b3bd997(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc36101f6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x3fa8c740(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x3aca31d7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xe5d4d300(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_combat_task(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2cf6f605(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x81591346(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf874aa52(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_align_ai(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2340b043(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),
0x56941eb7: ('stay_forever', _decode_stay_forever),
0xb553cda1: ('unknown_0xb553cda1', _decode_unknown_0xb553cda1),
0x53336240: ('unknown_0x53336240', _decode_unknown_0x53336240),
0x12341132: ('unknown_0x12341132', _decode_unknown_0x12341132),
0xaaccd7cd: ('unknown_0xaaccd7cd', _decode_unknown_0xaaccd7cd),
0xa2a5b38f: ('idle_animation', _decode_idle_animation),
0x799f6f58: ('unknown_0x799f6f58', _decode_unknown_0x799f6f58),
0x121045f5: ('unknown_0x121045f5', _decode_unknown_0x121045f5),
0xf470ea14: ('unknown_0xf470ea14', _decode_unknown_0xf470ea14),
0x7aa31371: ('unknown_0x7aa31371', _decode_unknown_0x7aa31371),
0xac4d7ad: ('unknown_0x0ac4d7ad', _decode_unknown_0x0ac4d7ad),
0x3d511b9: ('unknown_0x03d511b9', _decode_unknown_0x03d511b9),
0x2bd321da: ('unknown_0x2bd321da', _decode_unknown_0x2bd321da),
0x2b3bd997: ('unknown_0x2b3bd997', _decode_unknown_0x2b3bd997),
0xc36101f6: ('unknown_0xc36101f6', _decode_unknown_0xc36101f6),
0x3fa8c740: ('unknown_0x3fa8c740', _decode_unknown_0x3fa8c740),
0x3aca31d7: ('unknown_0x3aca31d7', _decode_unknown_0x3aca31d7),
0xe5d4d300: ('unknown_0xe5d4d300', _decode_unknown_0xe5d4d300),
0x2528f442: ('is_combat_task', _decode_is_combat_task),
0x2cf6f605: ('unknown_0x2cf6f605', _decode_unknown_0x2cf6f605),
0x81591346: ('unknown_0x81591346', _decode_unknown_0x81591346),
0xf874aa52: ('unknown_0xf874aa52', _decode_unknown_0xf874aa52),
0x5c20cf58: ('align_ai', _decode_align_ai),
0x2340b043: ('unknown_0x2340b043', _decode_unknown_0x2340b043),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AITaskPoint.py | 0.57069 | 0.255504 | AITaskPoint.py | 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
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class GuiSlider(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_widget_properties: GuiWidgetProperties = dataclasses.field(default_factory=GuiWidgetProperties)
min_value: float = dataclasses.field(default=0.0)
max_value: float = dataclasses.field(default=255.0)
increment: float = dataclasses.field(default=1.0)
slide_speed: float = dataclasses.field(default=1.0)
slide_sound: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
slide_sound_volume: int = dataclasses.field(default=127)
@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 'GSLD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x91\xce\xfa\x1e') # 0x91cefa1e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gui_widget_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b',\xcb\xbd\xfe') # 0x2ccbbdfe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_value))
data.write(b'l\x84\xc5\x88') # 0x6c84c588
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_value))
data.write(b'\x8ah\xdbR') # 0x8a68db52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.increment))
data.write(b'\xed\xb6\x06+') # 0xedb6062b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_speed))
data.write(b'+y\xea\x93') # 0x2b79ea93
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.slide_sound))
data.write(b' \xdd\xb6a') # 0x20ddb661
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.slide_sound_volume))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
gui_widget_properties=GuiWidgetProperties.from_json(data['gui_widget_properties']),
min_value=data['min_value'],
max_value=data['max_value'],
increment=data['increment'],
slide_speed=data['slide_speed'],
slide_sound=data['slide_sound'],
slide_sound_volume=data['slide_sound_volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_widget_properties': self.gui_widget_properties.to_json(),
'min_value': self.min_value,
'max_value': self.max_value,
'increment': self.increment,
'slide_speed': self.slide_speed,
'slide_sound': self.slide_sound,
'slide_sound_volume': self.slide_sound_volume,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_gui_widget_properties(data: typing.BinaryIO, property_size: int):
return GuiWidgetProperties.from_stream(data, property_size)
def _decode_min_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_increment(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_slide_sound_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x91cefa1e: ('gui_widget_properties', _decode_gui_widget_properties),
0x2ccbbdfe: ('min_value', _decode_min_value),
0x6c84c588: ('max_value', _decode_max_value),
0x8a68db52: ('increment', _decode_increment),
0xedb6062b: ('slide_speed', _decode_slide_speed),
0x2b79ea93: ('slide_sound', _decode_slide_sound),
0x20ddb661: ('slide_sound_volume', _decode_slide_sound_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GuiSlider.py | 0.561215 | 0.293677 | GuiSlider.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.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.PhazonHarvesterData import PhazonHarvesterData
@dataclasses.dataclass()
class PhazonHarvester(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
phazon_harvester_data: PhazonHarvesterData = dataclasses.field(default_factory=PhazonHarvesterData)
@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 'PHHR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PhazonHarvester.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={'detection_range': 15.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'\xd2\xdf\xd5$') # 0xd2dfd524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phazon_harvester_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']),
phazon_harvester_data=PhazonHarvesterData.from_json(data['phazon_harvester_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(),
'phazon_harvester_data': self.phazon_harvester_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={'detection_range': 15.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_phazon_harvester_data(data: typing.BinaryIO, property_size: int):
return PhazonHarvesterData.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),
0xd2dfd524: ('phazon_harvester_data', _decode_phazon_harvester_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhazonHarvester.py | 0.617282 | 0.326352 | PhazonHarvester.py | 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 HUDHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
hud_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
unknown_0x6078a651: float = dataclasses.field(default=15.0)
unknown_0xf00bb6bb: float = dataclasses.field(default=16.0)
icon_scale: float = dataclasses.field(default=1.0)
animation_time: float = dataclasses.field(default=0.0)
animation_frames: int = dataclasses.field(default=0)
unknown_0xd993f97b: int = dataclasses.field(default=15)
@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 'HHNT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xd8\x04G\xe0') # 0xd80447e0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.hud_texture))
data.write(b'`x\xa6Q') # 0x6078a651
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6078a651))
data.write(b'\xf0\x0b\xb6\xbb') # 0xf00bb6bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf00bb6bb))
data.write(b'\x1a\xd2G\xa1') # 0x1ad247a1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.icon_scale))
data.write(b'*S$Z') # 0x2a53245a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.animation_time))
data.write(b'n\x88\xd6\xad') # 0x6e88d6ad
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation_frames))
data.write(b'\xd9\x93\xf9{') # 0xd993f97b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xd993f97b))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
hud_texture=data['hud_texture'],
unknown_0x6078a651=data['unknown_0x6078a651'],
unknown_0xf00bb6bb=data['unknown_0xf00bb6bb'],
icon_scale=data['icon_scale'],
animation_time=data['animation_time'],
animation_frames=data['animation_frames'],
unknown_0xd993f97b=data['unknown_0xd993f97b'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'hud_texture': self.hud_texture,
'unknown_0x6078a651': self.unknown_0x6078a651,
'unknown_0xf00bb6bb': self.unknown_0xf00bb6bb,
'icon_scale': self.icon_scale,
'animation_time': self.animation_time,
'animation_frames': self.animation_frames,
'unknown_0xd993f97b': self.unknown_0xd993f97b,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_hud_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_unknown_0x6078a651(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf00bb6bb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_icon_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_animation_frames(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd993f97b(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),
0xd80447e0: ('hud_texture', _decode_hud_texture),
0x6078a651: ('unknown_0x6078a651', _decode_unknown_0x6078a651),
0xf00bb6bb: ('unknown_0xf00bb6bb', _decode_unknown_0xf00bb6bb),
0x1ad247a1: ('icon_scale', _decode_icon_scale),
0x2a53245a: ('animation_time', _decode_animation_time),
0x6e88d6ad: ('animation_frames', _decode_animation_frames),
0xd993f97b: ('unknown_0xd993f97b', _decode_unknown_0xd993f97b),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/HUDHint.py | 0.614278 | 0.296692 | HUDHint.py | 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.WallCrawlerData import WallCrawlerData
@dataclasses.dataclass()
class Parasite(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flavor: int = dataclasses.field(default=0)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
telegraph_distance: float = dataclasses.field(default=10.0)
waypoint_approach_distance: float = dataclasses.field(default=2.5)
wall_turn_speed: float = dataclasses.field(default=360.0)
floor_turn_speed: float = dataclasses.field(default=180.0)
down_turn_speed: float = dataclasses.field(default=120.0)
stuck_time: float = dataclasses.field(default=0.20000000298023224)
unknown_0xd5c25506: float = dataclasses.field(default=0.4000000059604645)
behavior_influence_radius: float = dataclasses.field(default=6.0)
separation_distance: float = dataclasses.field(default=2.5999999046325684)
separation_priority: float = dataclasses.field(default=1.0)
alignment_priority: float = dataclasses.field(default=0.800000011920929)
unknown_0x61959f0d: float = dataclasses.field(default=0.699999988079071)
path_following_priority: float = dataclasses.field(default=0.8999999761581421)
forward_moving_priority: float = dataclasses.field(default=0.20000000298023224)
player_avoidance_distance: float = dataclasses.field(default=1.2999999523162842)
player_avoidance_priority: float = dataclasses.field(default=0.20000000298023224)
parasite_visible_distance: float = dataclasses.field(default=40.0)
initially_paused: bool = dataclasses.field(default=False)
wall_crawler_properties: WallCrawlerData = dataclasses.field(default_factory=WallCrawlerData)
@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 'PARA'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Parasite.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x17') # 23 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbesrJ') # 0xbe73724a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flavor))
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 25.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.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)
data.write(b'\x84X\xb0\x03') # 0x8458b003
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.telegraph_distance))
data.write(b's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\xacG\xc6(') # 0xac47c628
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wall_turn_speed))
data.write(b'\x8eO{)') # 0x8e4f7b29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_turn_speed))
data.write(b'=<\x1bv') # 0x3d3c1b76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.down_turn_speed))
data.write(b'\x0e~6\x98') # 0xe7e3698
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stuck_time))
data.write(b'\xd5\xc2U\x06') # 0xd5c25506
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd5c25506))
data.write(b'(\x03a\xaa') # 0x280361aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.behavior_influence_radius))
data.write(b"\x01U\x9f'") # 0x1559f27
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_distance))
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'HA\xf1\xde') # 0x4841f1de
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alignment_priority))
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'\xae\x11\xf9u') # 0xae11f975
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.path_following_priority))
data.write(b'^jT\xb8') # 0x5e6a54b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_moving_priority))
data.write(b'\x95j\x12H') # 0x956a1248
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_avoidance_distance))
data.write(b'F\xacf\xab') # 0x46ac66ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_avoidance_priority))
data.write(b'N\xee\xc7\x85') # 0x4eeec785
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.parasite_visible_distance))
data.write(b'\xc3\xccC\x7f') # 0xc3cc437f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.initially_paused))
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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flavor=data['flavor'],
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
telegraph_distance=data['telegraph_distance'],
waypoint_approach_distance=data['waypoint_approach_distance'],
wall_turn_speed=data['wall_turn_speed'],
floor_turn_speed=data['floor_turn_speed'],
down_turn_speed=data['down_turn_speed'],
stuck_time=data['stuck_time'],
unknown_0xd5c25506=data['unknown_0xd5c25506'],
behavior_influence_radius=data['behavior_influence_radius'],
separation_distance=data['separation_distance'],
separation_priority=data['separation_priority'],
alignment_priority=data['alignment_priority'],
unknown_0x61959f0d=data['unknown_0x61959f0d'],
path_following_priority=data['path_following_priority'],
forward_moving_priority=data['forward_moving_priority'],
player_avoidance_distance=data['player_avoidance_distance'],
player_avoidance_priority=data['player_avoidance_priority'],
parasite_visible_distance=data['parasite_visible_distance'],
initially_paused=data['initially_paused'],
wall_crawler_properties=WallCrawlerData.from_json(data['wall_crawler_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flavor': self.flavor,
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'telegraph_distance': self.telegraph_distance,
'waypoint_approach_distance': self.waypoint_approach_distance,
'wall_turn_speed': self.wall_turn_speed,
'floor_turn_speed': self.floor_turn_speed,
'down_turn_speed': self.down_turn_speed,
'stuck_time': self.stuck_time,
'unknown_0xd5c25506': self.unknown_0xd5c25506,
'behavior_influence_radius': self.behavior_influence_radius,
'separation_distance': self.separation_distance,
'separation_priority': self.separation_priority,
'alignment_priority': self.alignment_priority,
'unknown_0x61959f0d': self.unknown_0x61959f0d,
'path_following_priority': self.path_following_priority,
'forward_moving_priority': self.forward_moving_priority,
'player_avoidance_distance': self.player_avoidance_distance,
'player_avoidance_priority': self.player_avoidance_priority,
'parasite_visible_distance': self.parasite_visible_distance,
'initially_paused': self.initially_paused,
'wall_crawler_properties': self.wall_crawler_properties.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flavor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_telegraph_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_waypoint_approach_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wall_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_floor_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_down_turn_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_stuck_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd5c25506(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_behavior_influence_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_separation_distance(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_alignment_priority(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_path_following_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_forward_moving_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_avoidance_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_avoidance_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_parasite_visible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_initially_paused(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wall_crawler_properties(data: typing.BinaryIO, property_size: int):
return WallCrawlerData.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),
0xbe73724a: ('flavor', _decode_flavor),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x8458b003: ('telegraph_distance', _decode_telegraph_distance),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0xac47c628: ('wall_turn_speed', _decode_wall_turn_speed),
0x8e4f7b29: ('floor_turn_speed', _decode_floor_turn_speed),
0x3d3c1b76: ('down_turn_speed', _decode_down_turn_speed),
0xe7e3698: ('stuck_time', _decode_stuck_time),
0xd5c25506: ('unknown_0xd5c25506', _decode_unknown_0xd5c25506),
0x280361aa: ('behavior_influence_radius', _decode_behavior_influence_radius),
0x1559f27: ('separation_distance', _decode_separation_distance),
0xd293ebc4: ('separation_priority', _decode_separation_priority),
0x4841f1de: ('alignment_priority', _decode_alignment_priority),
0x61959f0d: ('unknown_0x61959f0d', _decode_unknown_0x61959f0d),
0xae11f975: ('path_following_priority', _decode_path_following_priority),
0x5e6a54b8: ('forward_moving_priority', _decode_forward_moving_priority),
0x956a1248: ('player_avoidance_distance', _decode_player_avoidance_distance),
0x46ac66ab: ('player_avoidance_priority', _decode_player_avoidance_priority),
0x4eeec785: ('parasite_visible_distance', _decode_parasite_visible_distance),
0xc3cc437f: ('initially_paused', _decode_initially_paused),
0xb718b831: ('wall_crawler_properties', _decode_wall_crawler_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Parasite.py | 0.592902 | 0.263244 | Parasite.py | 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 Timer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=5.0)
random_adjust: float = dataclasses.field(default=0.0)
auto_start: bool = dataclasses.field(default=False)
loop: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.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 'TIMR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
data.write(b':\xd3\x9b1') # 0x3ad39b31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_adjust))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
time=data['time'],
random_adjust=data['random_adjust'],
auto_start=data['auto_start'],
loop=data['loop'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
'random_adjust': self.random_adjust,
'auto_start': self.auto_start,
'loop': self.loop,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_adjust(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44335aff: ('time', _decode_time),
0x3ad39b31: ('random_adjust', _decode_random_adjust),
0x3217dff8: ('auto_start', _decode_auto_start),
0xeda47ff6: ('loop', _decode_loop),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Timer.py | 0.611034 | 0.35407 | Timer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class LODController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0x00b17e5f: int = dataclasses.field(default=1)
model01: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance01: float = dataclasses.field(default=0.0)
model02: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance02: float = dataclasses.field(default=0.0)
model03: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance03: float = dataclasses.field(default=0.0)
model04: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance04: float = dataclasses.field(default=0.0)
model05: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance05: float = dataclasses.field(default=0.0)
model06: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance06: float = dataclasses.field(default=0.0)
model07: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance07: float = dataclasses.field(default=0.0)
model08: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance08: float = dataclasses.field(default=0.0)
model09: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance09: float = dataclasses.field(default=0.0)
model10: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
distance10: float = dataclasses.field(default=0.0)
unknown_0xb67e3bf9: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.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 'LODC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptLODController.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x17') # 23 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x00\xb1~_') # 0xb17e5f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x00b17e5f))
data.write(b'\x03\xbe\xe4~') # 0x3bee47e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model01))
data.write(b'\xa1\x01\x8e\xf9') # 0xa1018ef9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance01))
data.write(b'\x85*\x96\xd0') # 0x852a96d0
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model02))
data.write(b"'\x95\xfcW") # 0x2795fc57
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance02))
data.write(b'NvEu') # 0x4e764575
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model03))
data.write(b'\xec\xc9/\xf2') # 0xecc92ff2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance03))
data.write(b'Ssu\xcd') # 0x537375cd
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model04))
data.write(b'\xf1\xcc\x1fJ') # 0xf1cc1f4a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance04))
data.write(b'\x98/\xa6h') # 0x982fa668
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model05))
data.write(b':\x90\xcc\xef') # 0x3a90ccef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance05))
data.write(b'\x1e\xbb\xd4\xc6') # 0x1ebbd4c6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model06))
data.write(b'\xbc\x04\xbeA') # 0xbc04be41
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance06))
data.write(b'\xd5\xe7\x07c') # 0xd5e70763
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model07))
data.write(b'wXm\xe4') # 0x77586de4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance07))
data.write(b'$\xb1\xb5\xb6') # 0x24b1b5b6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model08))
data.write(b'\x86\x0e\xdf1') # 0x860edf31
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance08))
data.write(b'\xef\xedf\x13') # 0xefed6613
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model09))
data.write(b'MR\x0c\x94') # 0x4d520c94
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance09))
data.write(b'n\x95<o') # 0x6e953c6f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model10))
data.write(b'\xcc*V\xe8') # 0xcc2a56e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.distance10))
data.write(b'\xb6~;\xf9') # 0xb67e3bf9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb67e3bf9))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_0x00b17e5f=data['unknown_0x00b17e5f'],
model01=data['model01'],
distance01=data['distance01'],
model02=data['model02'],
distance02=data['distance02'],
model03=data['model03'],
distance03=data['distance03'],
model04=data['model04'],
distance04=data['distance04'],
model05=data['model05'],
distance05=data['distance05'],
model06=data['model06'],
distance06=data['distance06'],
model07=data['model07'],
distance07=data['distance07'],
model08=data['model08'],
distance08=data['distance08'],
model09=data['model09'],
distance09=data['distance09'],
model10=data['model10'],
distance10=data['distance10'],
unknown_0xb67e3bf9=data['unknown_0xb67e3bf9'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0x00b17e5f': self.unknown_0x00b17e5f,
'model01': self.model01,
'distance01': self.distance01,
'model02': self.model02,
'distance02': self.distance02,
'model03': self.model03,
'distance03': self.distance03,
'model04': self.model04,
'distance04': self.distance04,
'model05': self.model05,
'distance05': self.distance05,
'model06': self.model06,
'distance06': self.distance06,
'model07': self.model07,
'distance07': self.distance07,
'model08': self.model08,
'distance08': self.distance08,
'model09': self.model09,
'distance09': self.distance09,
'model10': self.model10,
'distance10': self.distance10,
'unknown_0xb67e3bf9': self.unknown_0xb67e3bf9,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0x00b17e5f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_model01(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance01(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model02(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance02(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model03(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance03(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model04(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance04(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model05(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance05(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model06(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance06(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model07(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance07(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model08(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance08(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model09(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance09(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_model10(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_distance10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb67e3bf9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb17e5f: ('unknown_0x00b17e5f', _decode_unknown_0x00b17e5f),
0x3bee47e: ('model01', _decode_model01),
0xa1018ef9: ('distance01', _decode_distance01),
0x852a96d0: ('model02', _decode_model02),
0x2795fc57: ('distance02', _decode_distance02),
0x4e764575: ('model03', _decode_model03),
0xecc92ff2: ('distance03', _decode_distance03),
0x537375cd: ('model04', _decode_model04),
0xf1cc1f4a: ('distance04', _decode_distance04),
0x982fa668: ('model05', _decode_model05),
0x3a90ccef: ('distance05', _decode_distance05),
0x1ebbd4c6: ('model06', _decode_model06),
0xbc04be41: ('distance06', _decode_distance06),
0xd5e70763: ('model07', _decode_model07),
0x77586de4: ('distance07', _decode_distance07),
0x24b1b5b6: ('model08', _decode_model08),
0x860edf31: ('distance08', _decode_distance08),
0xefed6613: ('model09', _decode_model09),
0x4d520c94: ('distance09', _decode_distance09),
0x6e953c6f: ('model10', _decode_model10),
0xcc2a56e8: ('distance10', _decode_distance10),
0xb67e3bf9: ('unknown_0xb67e3bf9', _decode_unknown_0xb67e3bf9),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/LODController.py | 0.613931 | 0.242581 | LODController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Spinner(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
forward_speed: float = dataclasses.field(default=0.0)
backward_speed: float = dataclasses.field(default=0.0)
unknown_0x449dd059: float = dataclasses.field(default=0.0)
unknown_0xfc849759: float = dataclasses.field(default=0.0)
shot_spinner: bool = dataclasses.field(default=False)
allow_wrap: bool = dataclasses.field(default=False)
no_backward: bool = dataclasses.field(default=False)
spline_control: bool = dataclasses.field(default=True)
unknown_0x865322ca: bool = dataclasses.field(default=False)
loop_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
start_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
stop_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 'SPIN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xdeOjv') # 0xde4f6a76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_speed))
data.write(b'T\xe1Z<') # 0x54e15a3c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.backward_speed))
data.write(b'D\x9d\xd0Y') # 0x449dd059
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x449dd059))
data.write(b'\xfc\x84\x97Y') # 0xfc849759
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfc849759))
data.write(b'PP\x1e\x17') # 0x50501e17
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.shot_spinner))
data.write(b'9\x83\xcb\xa7') # 0x3983cba7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.allow_wrap))
data.write(b'\xf1\xc8\xa0\xae') # 0xf1c8a0ae
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_backward))
data.write(b'\xe8\xf0\xa1\xce') # 0xe8f0a1ce
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.spline_control))
data.write(b'\x86S"\xca') # 0x865322ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x865322ca))
data.write(b'qGuz') # 0x7147757a
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.loop_sound))
data.write(b'\xa8\xccH\xb3') # 0xa8cc48b3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.start_sound))
data.write(b'\x12\xaf\xe4\x99') # 0x12afe499
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stop_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']),
forward_speed=data['forward_speed'],
backward_speed=data['backward_speed'],
unknown_0x449dd059=data['unknown_0x449dd059'],
unknown_0xfc849759=data['unknown_0xfc849759'],
shot_spinner=data['shot_spinner'],
allow_wrap=data['allow_wrap'],
no_backward=data['no_backward'],
spline_control=data['spline_control'],
unknown_0x865322ca=data['unknown_0x865322ca'],
loop_sound=data['loop_sound'],
start_sound=data['start_sound'],
stop_sound=data['stop_sound'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'forward_speed': self.forward_speed,
'backward_speed': self.backward_speed,
'unknown_0x449dd059': self.unknown_0x449dd059,
'unknown_0xfc849759': self.unknown_0xfc849759,
'shot_spinner': self.shot_spinner,
'allow_wrap': self.allow_wrap,
'no_backward': self.no_backward,
'spline_control': self.spline_control,
'unknown_0x865322ca': self.unknown_0x865322ca,
'loop_sound': self.loop_sound,
'start_sound': self.start_sound,
'stop_sound': self.stop_sound,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_forward_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_backward_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x449dd059(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfc849759(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shot_spinner(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_allow_wrap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_no_backward(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_spline_control(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x865322ca(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_start_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stop_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),
0xde4f6a76: ('forward_speed', _decode_forward_speed),
0x54e15a3c: ('backward_speed', _decode_backward_speed),
0x449dd059: ('unknown_0x449dd059', _decode_unknown_0x449dd059),
0xfc849759: ('unknown_0xfc849759', _decode_unknown_0xfc849759),
0x50501e17: ('shot_spinner', _decode_shot_spinner),
0x3983cba7: ('allow_wrap', _decode_allow_wrap),
0xf1c8a0ae: ('no_backward', _decode_no_backward),
0xe8f0a1ce: ('spline_control', _decode_spline_control),
0x865322ca: ('unknown_0x865322ca', _decode_unknown_0x865322ca),
0x7147757a: ('loop_sound', _decode_loop_sound),
0xa8cc48b3: ('start_sound', _decode_start_sound),
0x12afe499: ('stop_sound', _decode_stop_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Spinner.py | 0.564459 | 0.27217 | Spinner.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.FargullHatcherData import FargullHatcherData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class FargullHatcher(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fargull_hatcher_data: FargullHatcherData = dataclasses.field(default_factory=FargullHatcherData)
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 'FGHT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_FargullHatcher.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'\xf5[p\xe6') # 0xf55b70e6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fargull_hatcher_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={'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']),
fargull_hatcher_data=FargullHatcherData.from_json(data['fargull_hatcher_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(),
'fargull_hatcher_data': self.fargull_hatcher_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_fargull_hatcher_data(data: typing.BinaryIO, property_size: int):
return FargullHatcherData.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),
0xf55b70e6: ('fargull_hatcher_data', _decode_fargull_hatcher_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/FargullHatcher.py | 0.625781 | 0.341322 | FargullHatcher.py | 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.UnknownStruct54 import UnknownStruct54
@dataclasses.dataclass()
class RoomAcoustics(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
priority: enums.Priority = dataclasses.field(default=enums.Priority.Unknown2)
unknown_struct54: UnknownStruct54 = dataclasses.field(default_factory=UnknownStruct54)
@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 'RMAC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x0b\xe7\xca\x9e') # 0xbe7ca9e
data.write(b'\x00\x04') # size
self.priority.to_stream(data)
data.write(b'U[\x05^') # 0x555b055e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct54.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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=enums.Priority.from_json(data['priority']),
unknown_struct54=UnknownStruct54.from_json(data['unknown_struct54']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'priority': self.priority.to_json(),
'unknown_struct54': self.unknown_struct54.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 enums.Priority.from_stream(data)
def _decode_unknown_struct54(data: typing.BinaryIO, property_size: int):
return UnknownStruct54.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),
0xbe7ca9e: ('priority', _decode_priority),
0x555b055e: ('unknown_struct54', _decode_unknown_struct54),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/RoomAcoustics.py | 0.624752 | 0.332852 | RoomAcoustics.py | 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 HUDMemo(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
display_time: float = dataclasses.field(default=3.0)
clear_window: bool = dataclasses.field(default=True)
type_out: bool = dataclasses.field(default=True)
display_type: int = dataclasses.field(default=0)
message_type: enums.MessageType = dataclasses.field(default=enums.MessageType.Unknown1)
has_border: bool = dataclasses.field(default=False)
priority: int = dataclasses.field(default=1)
string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
index_into_string: int = dataclasses.field(default=0)
font_scale: float = dataclasses.field(default=1.0)
enable_play_alert: bool = dataclasses.field(default=True)
unknown_0xb7a3e235: bool = dataclasses.field(default=False)
unknown_0x8f115e7a: bool = dataclasses.field(default=False)
unknown_0xd25a8445: bool = dataclasses.field(default=False)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
caad: AssetId = dataclasses.field(metadata={'asset_types': ['CAAD']}, default=default_asset_id)
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
texture_static: float = dataclasses.field(default=0.0)
audio_stream: AssetId = dataclasses.field(metadata={'asset_types': ['STRM']}, 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 'MEMO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x1a&\xc1\xcc') # 0x1a26c1cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.display_time))
data.write(b'\x84\xe2Io') # 0x84e2496f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.clear_window))
data.write(b'\xaf\xd0\x15\x8e') # 0xafd0158e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.type_out))
data.write(b'J\xb3\xb9[') # 0x4ab3b95b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.display_type))
data.write(b'+N)\x0c') # 0x2b4e290c
data.write(b'\x00\x04') # size
self.message_type.to_stream(data)
data.write(b'\xe4\xc5L\x15') # 0xe4c54c15
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.has_border))
data.write(b'B\x08vP') # 0x42087650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.priority))
data.write(b'\x91\x82%\x0c') # 0x9182250c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.string))
data.write(b'd\x12B\x19') # 0x64124219
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.index_into_string))
data.write(b'\x01\x00\x9a\x8c') # 0x1009a8c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.font_scale))
data.write(b'\xfb\x0e\x87\xda') # 0xfb0e87da
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.enable_play_alert))
data.write(b'\xb7\xa3\xe25') # 0xb7a3e235
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb7a3e235))
data.write(b'\x8f\x11^z') # 0x8f115e7a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8f115e7a))
data.write(b'\xd2Z\x84E') # 0xd25a8445
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd25a8445))
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'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x95\xa1\x00\xab') # 0x95a100ab
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.caad))
data.write(b'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture))
data.write(b'F\xdc\xa5(') # 0x46dca528
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.texture_static))
data.write(b'\xe5\xde\xb9\xc4') # 0xe5deb9c4
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.audio_stream))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
display_time=data['display_time'],
clear_window=data['clear_window'],
type_out=data['type_out'],
display_type=data['display_type'],
message_type=enums.MessageType.from_json(data['message_type']),
has_border=data['has_border'],
priority=data['priority'],
string=data['string'],
index_into_string=data['index_into_string'],
font_scale=data['font_scale'],
enable_play_alert=data['enable_play_alert'],
unknown_0xb7a3e235=data['unknown_0xb7a3e235'],
unknown_0x8f115e7a=data['unknown_0x8f115e7a'],
unknown_0xd25a8445=data['unknown_0xd25a8445'],
animation=AnimationParameters.from_json(data['animation']),
model=data['model'],
caad=data['caad'],
texture=data['texture'],
texture_static=data['texture_static'],
audio_stream=data['audio_stream'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'display_time': self.display_time,
'clear_window': self.clear_window,
'type_out': self.type_out,
'display_type': self.display_type,
'message_type': self.message_type.to_json(),
'has_border': self.has_border,
'priority': self.priority,
'string': self.string,
'index_into_string': self.index_into_string,
'font_scale': self.font_scale,
'enable_play_alert': self.enable_play_alert,
'unknown_0xb7a3e235': self.unknown_0xb7a3e235,
'unknown_0x8f115e7a': self.unknown_0x8f115e7a,
'unknown_0xd25a8445': self.unknown_0xd25a8445,
'animation': self.animation.to_json(),
'model': self.model,
'caad': self.caad,
'texture': self.texture,
'texture_static': self.texture_static,
'audio_stream': self.audio_stream,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_display_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_clear_window(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_type_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_display_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_message_type(data: typing.BinaryIO, property_size: int):
return enums.MessageType.from_stream(data)
def _decode_has_border(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_index_into_string(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_font_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_enable_play_alert(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb7a3e235(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x8f115e7a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xd25a8445(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_caad(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_texture_static(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_audio_stream(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),
0x1a26c1cc: ('display_time', _decode_display_time),
0x84e2496f: ('clear_window', _decode_clear_window),
0xafd0158e: ('type_out', _decode_type_out),
0x4ab3b95b: ('display_type', _decode_display_type),
0x2b4e290c: ('message_type', _decode_message_type),
0xe4c54c15: ('has_border', _decode_has_border),
0x42087650: ('priority', _decode_priority),
0x9182250c: ('string', _decode_string),
0x64124219: ('index_into_string', _decode_index_into_string),
0x1009a8c: ('font_scale', _decode_font_scale),
0xfb0e87da: ('enable_play_alert', _decode_enable_play_alert),
0xb7a3e235: ('unknown_0xb7a3e235', _decode_unknown_0xb7a3e235),
0x8f115e7a: ('unknown_0x8f115e7a', _decode_unknown_0x8f115e7a),
0xd25a8445: ('unknown_0xd25a8445', _decode_unknown_0xd25a8445),
0xa3d63f44: ('animation', _decode_animation),
0xc27ffa8f: ('model', _decode_model),
0x95a100ab: ('caad', _decode_caad),
0xd1f65872: ('texture', _decode_texture),
0x46dca528: ('texture_static', _decode_texture_static),
0xe5deb9c4: ('audio_stream', _decode_audio_stream),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/HUDMemo.py | 0.564579 | 0.248306 | HUDMemo.py | 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.Vector2f import Vector2f
from retro_data_structures.properties.corruption.core.Color import Color
@dataclasses.dataclass()
class DistanceFog(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0x88e8d530: int = dataclasses.field(default=3630416747) # Choice
mode: int = dataclasses.field(default=0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=1.0, b=0.0, a=0.0))
near_far_plane: Vector2f = dataclasses.field(default_factory=Vector2f)
color_rate: float = dataclasses.field(default=0.0)
distance_rate: Vector2f = dataclasses.field(default_factory=Vector2f)
force_settings: bool = dataclasses.field(default=False)
is_two_sided: bool = dataclasses.field(default=False)
unknown_0xb7246843: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=1.0, b=0.0, a=0.0))
vector2f_0x520d1dd5: Vector2f = dataclasses.field(default_factory=Vector2f)
unknown_0xbc86052a: float = dataclasses.field(default=0.0)
vector2f_0xfba31a97: Vector2f = dataclasses.field(default_factory=Vector2f)
@classmethod
def game(cls) -> Game:
return Game.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 'DFOG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x88\xe8\xd50') # 0x88e8d530
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x88e8d530))
data.write(b'\t\xadc\xde') # 0x9ad63de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.mode))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'e \x08\xda') # 0x652008da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.near_far_plane.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b")\xabG'") # 0x29ab4727
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.color_rate))
data.write(b'\xcc\x8e\x0f\x98') # 0xcc8e0f98
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.distance_rate.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc5\x93[g') # 0xc5935b67
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.force_settings))
data.write(b'\xb5\xd1\xef\x02') # 0xb5d1ef02
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_two_sided))
data.write(b'\xb7$hC') # 0xb7246843
data.write(b'\x00\x10') # size
self.unknown_0xb7246843.to_stream(data)
data.write(b'R\r\x1d\xd5') # 0x520d1dd5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vector2f_0x520d1dd5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\x86\x05*') # 0xbc86052a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbc86052a))
data.write(b'\xfb\xa3\x1a\x97') # 0xfba31a97
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vector2f_0xfba31a97.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown_0x88e8d530=data['unknown_0x88e8d530'],
mode=data['mode'],
color=Color.from_json(data['color']),
near_far_plane=Vector2f.from_json(data['near_far_plane']),
color_rate=data['color_rate'],
distance_rate=Vector2f.from_json(data['distance_rate']),
force_settings=data['force_settings'],
is_two_sided=data['is_two_sided'],
unknown_0xb7246843=Color.from_json(data['unknown_0xb7246843']),
vector2f_0x520d1dd5=Vector2f.from_json(data['vector2f_0x520d1dd5']),
unknown_0xbc86052a=data['unknown_0xbc86052a'],
vector2f_0xfba31a97=Vector2f.from_json(data['vector2f_0xfba31a97']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0x88e8d530': self.unknown_0x88e8d530,
'mode': self.mode,
'color': self.color.to_json(),
'near_far_plane': self.near_far_plane.to_json(),
'color_rate': self.color_rate,
'distance_rate': self.distance_rate.to_json(),
'force_settings': self.force_settings,
'is_two_sided': self.is_two_sided,
'unknown_0xb7246843': self.unknown_0xb7246843.to_json(),
'vector2f_0x520d1dd5': self.vector2f_0x520d1dd5.to_json(),
'unknown_0xbc86052a': self.unknown_0xbc86052a,
'vector2f_0xfba31a97': self.vector2f_0xfba31a97.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_unknown_0x88e8d530(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_near_far_plane(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
def _decode_color_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_distance_rate(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
def _decode_force_settings(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_two_sided(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb7246843(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_vector2f_0x520d1dd5(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
def _decode_unknown_0xbc86052a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vector2f_0xfba31a97(data: typing.BinaryIO, property_size: int):
return Vector2f.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x88e8d530: ('unknown_0x88e8d530', _decode_unknown_0x88e8d530),
0x9ad63de: ('mode', _decode_mode),
0x37c7d09d: ('color', _decode_color),
0x652008da: ('near_far_plane', _decode_near_far_plane),
0x29ab4727: ('color_rate', _decode_color_rate),
0xcc8e0f98: ('distance_rate', _decode_distance_rate),
0xc5935b67: ('force_settings', _decode_force_settings),
0xb5d1ef02: ('is_two_sided', _decode_is_two_sided),
0xb7246843: ('unknown_0xb7246843', _decode_unknown_0xb7246843),
0x520d1dd5: ('vector2f_0x520d1dd5', _decode_vector2f_0x520d1dd5),
0xbc86052a: ('unknown_0xbc86052a', _decode_unknown_0xbc86052a),
0xfba31a97: ('vector2f_0xfba31a97', _decode_vector2f_0xfba31a97),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DistanceFog.py | 0.57069 | 0.361869 | DistanceFog.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CameraBlurKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
blur_type: int = dataclasses.field(default=0)
blur_radius: float = dataclasses.field(default=0.0)
which_filter_group: int = dataclasses.field(default=0)
interpolate_in_time: float = dataclasses.field(default=0.0)
interpolate_out_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.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 'BLUR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe95\x91H') # 0xe9359148
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blur_type))
data.write(b'on\xb1\xf4') # 0x6f6eb1f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.blur_radius))
data.write(b'?\xdcK.') # 0x3fdc4b2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_filter_group))
data.write(b'\xab\xd4\x1a6') # 0xabd41a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_in_time))
data.write(b'>\xafx\xfe') # 0x3eaf78fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
blur_type=data['blur_type'],
blur_radius=data['blur_radius'],
which_filter_group=data['which_filter_group'],
interpolate_in_time=data['interpolate_in_time'],
interpolate_out_time=data['interpolate_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'blur_type': self.blur_type,
'blur_radius': self.blur_radius,
'which_filter_group': self.which_filter_group,
'interpolate_in_time': self.interpolate_in_time,
'interpolate_out_time': self.interpolate_out_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_blur_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_blur_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_which_filter_group(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_interpolate_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_interpolate_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe9359148: ('blur_type', _decode_blur_type),
0x6f6eb1f4: ('blur_radius', _decode_blur_radius),
0x3fdc4b2e: ('which_filter_group', _decode_which_filter_group),
0xabd41a36: ('interpolate_in_time', _decode_interpolate_in_time),
0x3eaf78fe: ('interpolate_out_time', _decode_interpolate_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CameraBlurKeyframe.py | 0.609408 | 0.319294 | CameraBlurKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.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.VisorParameters import VisorParameters
@dataclasses.dataclass()
class DamageableTrigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
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)
only_take_damage_from_inhabitants: bool = dataclasses.field(default=False)
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 'DTRG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xce,\xf5\x10') # 0xce2cf510
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.only_take_damage_from_inhabitants))
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']),
only_take_damage_from_inhabitants=data['only_take_damage_from_inhabitants'],
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(),
'only_take_damage_from_inhabitants': self.only_take_damage_from_inhabitants,
'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_only_take_damage_from_inhabitants(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_hostile(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
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),
0xce2cf510: ('only_take_damage_from_inhabitants', _decode_only_take_damage_from_inhabitants),
0x701b61b3: ('is_hostile', _decode_is_hostile),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/DamageableTrigger.py | 0.574992 | 0.369287 | DamageableTrigger.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class MiiAccessory(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_parameters: 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 'MIIA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xd2\x9c\x03\x1d') # 0xd29c031d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_parameters.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_parameters=ActorParameters.from_json(data['actor_parameters']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_parameters': self.actor_parameters.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_actor_parameters(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd29c031d: ('actor_parameters', _decode_actor_parameters),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MiiAccessory.py | 0.648244 | 0.329594 | MiiAccessory.py | 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.SavedStateID import SavedStateID
@dataclasses.dataclass()
class MemoryRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
object_id: SavedStateID = dataclasses.field(default_factory=SavedStateID)
one_shot: bool = dataclasses.field(default=False)
delayed_action: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.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 'MRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\xd9\xa7]') # 0x16d9a75d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.object_id.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
data.write(b'\xa9\x05\xcc\xf0') # 0xa905ccf0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.delayed_action))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
object_id=SavedStateID.from_json(data['object_id']),
one_shot=data['one_shot'],
delayed_action=data['delayed_action'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'object_id': self.object_id.to_json(),
'one_shot': self.one_shot,
'delayed_action': self.delayed_action,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_object_id(data: typing.BinaryIO, property_size: int):
return SavedStateID.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_delayed_action(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x16d9a75d: ('object_id', _decode_object_id),
0xead7b7bb: ('one_shot', _decode_one_shot),
0xa905ccf0: ('delayed_action', _decode_delayed_action),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/MemoryRelay.py | 0.588771 | 0.326003 | MemoryRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class PlayerUserAnimPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
attach_dist: float = dataclasses.field(default=0.75)
unknown_0xad2d4f53: float = dataclasses.field(default=1.0)
unknown_0x285b4540: float = dataclasses.field(default=0.0)
unknown_0x6806d0b3: float = dataclasses.field(default=0.10000000149011612)
unknown_0x1ce620a7: int = dataclasses.field(default=5)
@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 'PUAP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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"d='i") # 0x643d2769
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attach_dist))
data.write(b'\xad-OS') # 0xad2d4f53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xad2d4f53))
data.write(b'([E@') # 0x285b4540
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x285b4540))
data.write(b'h\x06\xd0\xb3') # 0x6806d0b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6806d0b3))
data.write(b'\x1c\xe6 \xa7') # 0x1ce620a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x1ce620a7))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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=AnimationParameters.from_json(data['animation']),
attach_dist=data['attach_dist'],
unknown_0xad2d4f53=data['unknown_0xad2d4f53'],
unknown_0x285b4540=data['unknown_0x285b4540'],
unknown_0x6806d0b3=data['unknown_0x6806d0b3'],
unknown_0x1ce620a7=data['unknown_0x1ce620a7'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation': self.animation.to_json(),
'attach_dist': self.attach_dist,
'unknown_0xad2d4f53': self.unknown_0xad2d4f53,
'unknown_0x285b4540': self.unknown_0x285b4540,
'unknown_0x6806d0b3': self.unknown_0x6806d0b3,
'unknown_0x1ce620a7': self.unknown_0x1ce620a7,
}
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 AnimationParameters.from_stream(data, property_size)
def _decode_attach_dist(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xad2d4f53(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x285b4540(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6806d0b3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1ce620a7(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),
0xa3d63f44: ('animation', _decode_animation),
0x643d2769: ('attach_dist', _decode_attach_dist),
0xad2d4f53: ('unknown_0xad2d4f53', _decode_unknown_0xad2d4f53),
0x285b4540: ('unknown_0x285b4540', _decode_unknown_0x285b4540),
0x6806d0b3: ('unknown_0x6806d0b3', _decode_unknown_0x6806d0b3),
0x1ce620a7: ('unknown_0x1ce620a7', _decode_unknown_0x1ce620a7),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PlayerUserAnimPoint.py | 0.596786 | 0.340896 | PlayerUserAnimPoint.py | 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.SeedBoss1OrbData import SeedBoss1OrbData
@dataclasses.dataclass()
class SeedBoss1Orb(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
seed_boss1_orb_data: SeedBoss1OrbData = dataclasses.field(default_factory=SeedBoss1OrbData)
@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 'SBO1'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SeedBoss1.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'\xeeS\xeb\xe7') # 0xee53ebe7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.seed_boss1_orb_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']),
seed_boss1_orb_data=SeedBoss1OrbData.from_json(data['seed_boss1_orb_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(),
'seed_boss1_orb_data': self.seed_boss1_orb_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_seed_boss1_orb_data(data: typing.BinaryIO, property_size: int):
return SeedBoss1OrbData.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),
0xee53ebe7: ('seed_boss1_orb_data', _decode_seed_boss1_orb_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SeedBoss1Orb.py | 0.62223 | 0.351283 | SeedBoss1Orb.py | 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.UnknownStruct47 import UnknownStruct47
@dataclasses.dataclass()
class Metaree(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_struct47: UnknownStruct47 = dataclasses.field(default_factory=UnknownStruct47)
@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 'MREE'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_Metaree.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={'detection_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'\xe9\x9c&J') # 0xe99c264a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct47.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_struct47=UnknownStruct47.from_json(data['unknown_struct47']),
)
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_struct47': self.unknown_struct47.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': 30.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct47(data: typing.BinaryIO, property_size: int):
return UnknownStruct47.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),
0xe99c264a: ('unknown_struct47', _decode_unknown_struct47),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Metaree.py | 0.625095 | 0.333612 | Metaree.py | 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 TeamAI(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
max_team_size: int = dataclasses.field(default=20)
max_melee_attackers: int = dataclasses.field(default=2)
max_ranged_attackers: int = dataclasses.field(default=2)
max_special_attackers: int = dataclasses.field(default=0)
unknown_0x9fa9c457: int = dataclasses.field(default=30)
unknown_0x54cd2755: int = dataclasses.field(default=1)
unknown_0xc36ed15c: int = dataclasses.field(default=1)
unknown_0x69cde528: int = dataclasses.field(default=1)
team_formation: int = dataclasses.field(default=0)
unknown_0xd3ad55b6: float = dataclasses.field(default=0.0)
unknown_0x8d00b839: float = dataclasses.field(default=0.0)
unknown_0x9856e6f0: float = dataclasses.field(default=0.0)
max_hypermode_members: 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 'TMAI'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptTeamAiMgr.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbf7\xe5\x18') # 0xbf37e518
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_team_size))
data.write(b'\xce\xbe\xe4\xab') # 0xcebee4ab
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_melee_attackers))
data.write(b'uU\xc1\xea') # 0x7555c1ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_ranged_attackers))
data.write(b'\x1c:6\\') # 0x1c3a365c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_special_attackers))
data.write(b'\x9f\xa9\xc4W') # 0x9fa9c457
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x9fa9c457))
data.write(b"T\xcd'U") # 0x54cd2755
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x54cd2755))
data.write(b'\xc3n\xd1\\') # 0xc36ed15c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc36ed15c))
data.write(b'i\xcd\xe5(') # 0x69cde528
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x69cde528))
data.write(b'7\xa2\x03v') # 0x37a20376
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.team_formation))
data.write(b'\xd3\xadU\xb6') # 0xd3ad55b6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd3ad55b6))
data.write(b'\x8d\x00\xb89') # 0x8d00b839
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8d00b839))
data.write(b'\x98V\xe6\xf0') # 0x9856e6f0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9856e6f0))
data.write(b'F\xb9N,') # 0x46b94e2c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_hypermode_members))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
max_team_size=data['max_team_size'],
max_melee_attackers=data['max_melee_attackers'],
max_ranged_attackers=data['max_ranged_attackers'],
max_special_attackers=data['max_special_attackers'],
unknown_0x9fa9c457=data['unknown_0x9fa9c457'],
unknown_0x54cd2755=data['unknown_0x54cd2755'],
unknown_0xc36ed15c=data['unknown_0xc36ed15c'],
unknown_0x69cde528=data['unknown_0x69cde528'],
team_formation=data['team_formation'],
unknown_0xd3ad55b6=data['unknown_0xd3ad55b6'],
unknown_0x8d00b839=data['unknown_0x8d00b839'],
unknown_0x9856e6f0=data['unknown_0x9856e6f0'],
max_hypermode_members=data['max_hypermode_members'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'max_team_size': self.max_team_size,
'max_melee_attackers': self.max_melee_attackers,
'max_ranged_attackers': self.max_ranged_attackers,
'max_special_attackers': self.max_special_attackers,
'unknown_0x9fa9c457': self.unknown_0x9fa9c457,
'unknown_0x54cd2755': self.unknown_0x54cd2755,
'unknown_0xc36ed15c': self.unknown_0xc36ed15c,
'unknown_0x69cde528': self.unknown_0x69cde528,
'team_formation': self.team_formation,
'unknown_0xd3ad55b6': self.unknown_0xd3ad55b6,
'unknown_0x8d00b839': self.unknown_0x8d00b839,
'unknown_0x9856e6f0': self.unknown_0x9856e6f0,
'max_hypermode_members': self.max_hypermode_members,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_max_team_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_melee_attackers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_ranged_attackers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_special_attackers(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x9fa9c457(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x54cd2755(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc36ed15c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x69cde528(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_team_formation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xd3ad55b6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8d00b839(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9856e6f0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_hypermode_members(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),
0xbf37e518: ('max_team_size', _decode_max_team_size),
0xcebee4ab: ('max_melee_attackers', _decode_max_melee_attackers),
0x7555c1ea: ('max_ranged_attackers', _decode_max_ranged_attackers),
0x1c3a365c: ('max_special_attackers', _decode_max_special_attackers),
0x9fa9c457: ('unknown_0x9fa9c457', _decode_unknown_0x9fa9c457),
0x54cd2755: ('unknown_0x54cd2755', _decode_unknown_0x54cd2755),
0xc36ed15c: ('unknown_0xc36ed15c', _decode_unknown_0xc36ed15c),
0x69cde528: ('unknown_0x69cde528', _decode_unknown_0x69cde528),
0x37a20376: ('team_formation', _decode_team_formation),
0xd3ad55b6: ('unknown_0xd3ad55b6', _decode_unknown_0xd3ad55b6),
0x8d00b839: ('unknown_0x8d00b839', _decode_unknown_0x8d00b839),
0x9856e6f0: ('unknown_0x9856e6f0', _decode_unknown_0x9856e6f0),
0x46b94e2c: ('max_hypermode_members', _decode_max_hypermode_members),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/TeamAI.py | 0.593256 | 0.267217 | TeamAI.py | 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.PirateDroneData import PirateDroneData
@dataclasses.dataclass()
class PirateDrone(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
pirate_drone_data: PirateDroneData = dataclasses.field(default_factory=PirateDroneData)
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 'PDRN'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_PirateDrone.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'\x16\xe8\xd4\xe8') # 0x16e8d4e8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pirate_drone_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={'creature_size': 1, 'detection_range': 50.0, 'freeze_duration': 10.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']),
pirate_drone_data=PirateDroneData.from_json(data['pirate_drone_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(),
'pirate_drone_data': self.pirate_drone_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_pirate_drone_data(data: typing.BinaryIO, property_size: int):
return PirateDroneData.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'creature_size': 1, 'detection_range': 50.0, 'freeze_duration': 10.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),
0x16e8d4e8: ('pirate_drone_data', _decode_pirate_drone_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/PirateDrone.py | 0.634656 | 0.319161 | PirateDrone.py | 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.BonusCredit import BonusCredit
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 Achievement(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
bonus_credit: BonusCredit = dataclasses.field(default_factory=BonusCredit)
achievement: enums.Achievement = dataclasses.field(default=enums.Achievement.Unknown84)
normal_difficulty: bool = dataclasses.field(default=True)
hard_difficulty: bool = dataclasses.field(default=True)
elite_difficulty: bool = dataclasses.field(default=True)
bonus_credit_string: 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 'ACHI'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptAchievement.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'z\xac\x9e"') # 0x7aac9e22
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bonus_credit.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05\x8d-\xdb') # 0x58d2ddb
data.write(b'\x00\x04') # size
self.achievement.to_stream(data)
data.write(b'\x97OJ\xa1') # 0x974f4aa1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.normal_difficulty))
data.write(b'\x0f\x8c\xf6\xff') # 0xf8cf6ff
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.hard_difficulty))
data.write(b'\x9b\x89\x03\xeb') # 0x9b8903eb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.elite_difficulty))
data.write(b'\xd6\xa0\xcf\xf1') # 0xd6a0cff1
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bonus_credit_string))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
bonus_credit=BonusCredit.from_json(data['bonus_credit']),
achievement=enums.Achievement.from_json(data['achievement']),
normal_difficulty=data['normal_difficulty'],
hard_difficulty=data['hard_difficulty'],
elite_difficulty=data['elite_difficulty'],
bonus_credit_string=data['bonus_credit_string'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'bonus_credit': self.bonus_credit.to_json(),
'achievement': self.achievement.to_json(),
'normal_difficulty': self.normal_difficulty,
'hard_difficulty': self.hard_difficulty,
'elite_difficulty': self.elite_difficulty,
'bonus_credit_string': self.bonus_credit_string,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_bonus_credit(data: typing.BinaryIO, property_size: int):
return BonusCredit.from_stream(data, property_size)
def _decode_achievement(data: typing.BinaryIO, property_size: int):
return enums.Achievement.from_stream(data)
def _decode_normal_difficulty(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_hard_difficulty(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_elite_difficulty(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_bonus_credit_string(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),
0x7aac9e22: ('bonus_credit', _decode_bonus_credit),
0x58d2ddb: ('achievement', _decode_achievement),
0x974f4aa1: ('normal_difficulty', _decode_normal_difficulty),
0xf8cf6ff: ('hard_difficulty', _decode_hard_difficulty),
0x9b8903eb: ('elite_difficulty', _decode_elite_difficulty),
0xd6a0cff1: ('bonus_credit_string', _decode_bonus_credit_string),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Achievement.py | 0.587352 | 0.323433 | Achievement.py | 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.UnknownStruct63 import UnknownStruct63
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 ShipHudControl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_struct63: UnknownStruct63 = dataclasses.field(default_factory=UnknownStruct63)
@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 'SHHC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\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'\xe7\xf9*\xbc') # 0xe7f92abc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct63.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
model=data['model'],
animation=AnimationParameters.from_json(data['animation']),
unknown_struct63=UnknownStruct63.from_json(data['unknown_struct63']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'model': self.model,
'animation': self.animation.to_json(),
'unknown_struct63': self.unknown_struct63.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_struct63(data: typing.BinaryIO, property_size: int):
return UnknownStruct63.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc27ffa8f: ('model', _decode_model),
0xa3d63f44: ('animation', _decode_animation),
0xe7f92abc: ('unknown_struct63', _decode_unknown_struct63),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ShipHudControl.py | 0.657318 | 0.285106 | ShipHudControl.py | 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.KorbaSnatcherData import KorbaSnatcherData
from retro_data_structures.properties.corruption.archetypes.SwarmBasicsData import SwarmBasicsData
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class KorbaSnatcherSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
korba_snatcher_properties: KorbaSnatcherData = dataclasses.field(default_factory=KorbaSnatcherData)
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_0x92827035: float = dataclasses.field(default=0.44999998807907104)
unknown_0xdc30cb20: int = dataclasses.field(default=0)
unknown_0x48387110: int = dataclasses.field(default=0)
unknown_0x5d054897: 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 'KRBA'
@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\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'U\x06\tK') # 0x5506094b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.korba_snatcher_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'\x92\x82p5') # 0x92827035
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x92827035))
data.write(b'\xdc0\xcb ') # 0xdc30cb20
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xdc30cb20))
data.write(b'H8q\x10') # 0x48387110
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x48387110))
data.write(b']\x05H\x97') # 0x5d054897
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x5d054897))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_snatcher_properties=KorbaSnatcherData.from_json(data['korba_snatcher_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_0x92827035=data['unknown_0x92827035'],
unknown_0xdc30cb20=data['unknown_0xdc30cb20'],
unknown_0x48387110=data['unknown_0x48387110'],
unknown_0x5d054897=data['unknown_0x5d054897'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'korba_snatcher_properties': self.korba_snatcher_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_0x92827035': self.unknown_0x92827035,
'unknown_0xdc30cb20': self.unknown_0xdc30cb20,
'unknown_0x48387110': self.unknown_0x48387110,
'unknown_0x5d054897': self.unknown_0x5d054897,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_korba_snatcher_properties(data: typing.BinaryIO, property_size: int):
return KorbaSnatcherData.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_0x92827035(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xdc30cb20(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x48387110(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x5d054897(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),
0x5506094b: ('korba_snatcher_properties', _decode_korba_snatcher_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),
0x92827035: ('unknown_0x92827035', _decode_unknown_0x92827035),
0xdc30cb20: ('unknown_0xdc30cb20', _decode_unknown_0xdc30cb20),
0x48387110: ('unknown_0x48387110', _decode_unknown_0x48387110),
0x5d054897: ('unknown_0x5d054897', _decode_unknown_0x5d054897),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/KorbaSnatcherSwarm.py | 0.567937 | 0.312213 | KorbaSnatcherSwarm.py | 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 ContextSensitiveActivator(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
player_distance: float = dataclasses.field(default=5.0)
face_angle: float = dataclasses.field(default=90.0)
screen_center_distance: float = dataclasses.field(default=20.0)
unknown: bool = dataclasses.field(default=False)
reticule_type: enums.ReticuleType = dataclasses.field(default=enums.ReticuleType.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 'CSAT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptContextSensitiveActivator.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'?]\x07!') # 0x3f5d0721
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_distance))
data.write(b'\x1eJ3\xdc') # 0x1e4a33dc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.face_angle))
data.write(b'\xe7\xe3\xe1\x9f') # 0xe7e3e19f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.screen_center_distance))
data.write(b'\xf2\xe2?0') # 0xf2e23f30
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x87\xa1\xc2\x04') # 0x87a1c204
data.write(b'\x00\x04') # size
self.reticule_type.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
player_distance=data['player_distance'],
face_angle=data['face_angle'],
screen_center_distance=data['screen_center_distance'],
unknown=data['unknown'],
reticule_type=enums.ReticuleType.from_json(data['reticule_type']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'player_distance': self.player_distance,
'face_angle': self.face_angle,
'screen_center_distance': self.screen_center_distance,
'unknown': self.unknown,
'reticule_type': self.reticule_type.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_player_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_face_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_screen_center_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_reticule_type(data: typing.BinaryIO, property_size: int):
return enums.ReticuleType.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3f5d0721: ('player_distance', _decode_player_distance),
0x1e4a33dc: ('face_angle', _decode_face_angle),
0xe7e3e19f: ('screen_center_distance', _decode_screen_center_distance),
0xf2e23f30: ('unknown', _decode_unknown),
0x87a1c204: ('reticule_type', _decode_reticule_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ContextSensitiveActivator.py | 0.620852 | 0.332107 | ContextSensitiveActivator.py | 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.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.StaticGeometryTest import StaticGeometryTest
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
from retro_data_structures.properties.corruption.core.Spline import Spline
from retro_data_structures.properties.corruption.core.Vector import Vector
@dataclasses.dataclass()
class Actor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
mass: float = dataclasses.field(default=1.0)
gravity: float = dataclasses.field(default=0.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
character_animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
is_loop: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
is_solid: bool = dataclasses.field(default=True)
is_camera_through: bool = dataclasses.field(default=False)
render_texture_set: int = dataclasses.field(default=0)
draws_shadow: bool = dataclasses.field(default=False)
render_first_sorted: bool = dataclasses.field(default=False)
scale_animation: bool = dataclasses.field(default=True)
unknown_0xa09d4a1f: bool = dataclasses.field(default=False)
is_phaazite: bool = dataclasses.field(default=False)
unknown_0xaa49b627: float = dataclasses.field(default=1.0)
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)
random_animation_offset: float = dataclasses.field(default=0.0)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
projectile_static_geometry_test: StaticGeometryTest = dataclasses.field(default_factory=StaticGeometryTest)
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)
@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 'ACTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1f') # 31 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.model))
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.collision_model))
data.write(b'\xa2D\xc9\xd8') # 0xa244c9d8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.character_animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'xY\xb5 ') # 0x7859b520
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_camera_through))
data.write(b'2\xfa\xb9~') # 0x32fab97e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_texture_set))
data.write(b'\x97htF') # 0x97687446
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.draws_shadow))
data.write(b'GC)O') # 0x4743294f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_first_sorted))
data.write(b'&\x1e\x92\xa4') # 0x261e92a4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.scale_animation))
data.write(b'\xa0\x9dJ\x1f') # 0xa09d4a1f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa09d4a1f))
data.write(b'\xf3\xde\x93\x11') # 0xf3de9311
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_phaazite))
data.write(b"\xaaI\xb6'") # 0xaa49b627
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xaa49b627))
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'\xbfi\xc0>') # 0xbf69c03e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_animation_offset))
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.projectile))
data.write(b'U;\x139') # 0x553b1339
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9a\x89(\x18') # 0x9a892818
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_static_geometry_test.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))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
mass=data['mass'],
gravity=data['gravity'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
model=data['model'],
collision_model=data['collision_model'],
character_animation_information=AnimationParameters.from_json(data['character_animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
is_loop=data['is_loop'],
immovable=data['immovable'],
is_solid=data['is_solid'],
is_camera_through=data['is_camera_through'],
render_texture_set=data['render_texture_set'],
draws_shadow=data['draws_shadow'],
render_first_sorted=data['render_first_sorted'],
scale_animation=data['scale_animation'],
unknown_0xa09d4a1f=data['unknown_0xa09d4a1f'],
is_phaazite=data['is_phaazite'],
unknown_0xaa49b627=data['unknown_0xaa49b627'],
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']),
random_animation_offset=data['random_animation_offset'],
projectile=data['projectile'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
projectile_static_geometry_test=StaticGeometryTest.from_json(data['projectile_static_geometry_test']),
orbit_offset=Vector.from_json(data['orbit_offset']),
orbit_offset_local=data['orbit_offset_local'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'mass': self.mass,
'gravity': self.gravity,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'model': self.model,
'collision_model': self.collision_model,
'character_animation_information': self.character_animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'is_loop': self.is_loop,
'immovable': self.immovable,
'is_solid': self.is_solid,
'is_camera_through': self.is_camera_through,
'render_texture_set': self.render_texture_set,
'draws_shadow': self.draws_shadow,
'render_first_sorted': self.render_first_sorted,
'scale_animation': self.scale_animation,
'unknown_0xa09d4a1f': self.unknown_0xa09d4a1f,
'is_phaazite': self.is_phaazite,
'unknown_0xaa49b627': self.unknown_0xaa49b627,
'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(),
'random_animation_offset': self.random_animation_offset,
'projectile': self.projectile,
'projectile_damage': self.projectile_damage.to_json(),
'projectile_static_geometry_test': self.projectile_static_geometry_test.to_json(),
'orbit_offset': self.orbit_offset.to_json(),
'orbit_offset_local': self.orbit_offset_local,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_character_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_is_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_camera_through(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_texture_set(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_draws_shadow(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_first_sorted(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_scale_animation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa09d4a1f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_phaazite(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xaa49b627(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[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_random_animation_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_projectile_static_geometry_test(data: typing.BinaryIO, property_size: int):
return StaticGeometryTest.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]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x75dbb375: ('mass', _decode_mass),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0xc27ffa8f: ('model', _decode_model),
0xfc966dc: ('collision_model', _decode_collision_model),
0xa244c9d8: ('character_animation_information', _decode_character_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x1e32523e: ('immovable', _decode_immovable),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x7859b520: ('is_camera_through', _decode_is_camera_through),
0x32fab97e: ('render_texture_set', _decode_render_texture_set),
0x97687446: ('draws_shadow', _decode_draws_shadow),
0x4743294f: ('render_first_sorted', _decode_render_first_sorted),
0x261e92a4: ('scale_animation', _decode_scale_animation),
0xa09d4a1f: ('unknown_0xa09d4a1f', _decode_unknown_0xa09d4a1f),
0xf3de9311: ('is_phaazite', _decode_is_phaazite),
0xaa49b627: ('unknown_0xaa49b627', _decode_unknown_0xaa49b627),
0xb530d7de: ('use_mod_inca', _decode_use_mod_inca),
0xf8df6cd2: ('mod_inca_color', _decode_mod_inca_color),
0xc23011d9: ('mod_inca_amount', _decode_mod_inca_amount),
0xbf69c03e: ('random_animation_offset', _decode_random_animation_offset),
0xef485db9: ('projectile', _decode_projectile),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0x9a892818: ('projectile_static_geometry_test', _decode_projectile_static_geometry_test),
0x850115e4: ('orbit_offset', _decode_orbit_offset),
0xe73f123d: ('orbit_offset_local', _decode_orbit_offset_local),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Actor.py | 0.639398 | 0.256826 | Actor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.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.PhazonFlyerSwarmData import PhazonFlyerSwarmData
from retro_data_structures.properties.corruption.archetypes.SwarmBasicsData import SwarmBasicsData
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class PhazonFlyerSwarm(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)
phazon_flyer_swarm_data: PhazonFlyerSwarmData = dataclasses.field(default_factory=PhazonFlyerSwarmData)
@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 'PHZS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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)
data.write(b'\x10\r\x1f\xd2') # 0x100d1fd2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.phazon_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']),
phazon_flyer_swarm_data=PhazonFlyerSwarmData.from_json(data['phazon_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(),
'phazon_flyer_swarm_data': self.phazon_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)
def _decode_phazon_flyer_swarm_data(data: typing.BinaryIO, property_size: int):
return PhazonFlyerSwarmData.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),
0x100d1fd2: ('phazon_flyer_swarm_data', _decode_phazon_flyer_swarm_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PhazonFlyerSwarm.py | 0.5564 | 0.251096 | PhazonFlyerSwarm.py | 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.PlayerActorStruct import PlayerActorStruct
from retro_data_structures.properties.corruption.archetypes.ShadowProjection import ShadowProjection
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 PlayerActor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
mass: float = dataclasses.field(default=1.0)
gravity: float = dataclasses.field(default=0.0)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
no_model: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
is_loop: bool = dataclasses.field(default=True)
immovable: bool = dataclasses.field(default=True)
is_solid: bool = dataclasses.field(default=True)
empty_suit_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
empty_suit_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
varia_suit_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
varia_suit_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
varia_suit_grapple_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
varia_suit_grapple_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
stage01_suit_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
stage01_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
stage02_suit_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
stage02_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
stage03_suit_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
stage03_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
stage03_acid_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
stage03_acid_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
stage04_suit_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
stage04_skin_rule: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
player_actor_struct_0x1098d091: PlayerActorStruct = dataclasses.field(default_factory=PlayerActorStruct)
player_actor_struct_0xc7385390: PlayerActorStruct = dataclasses.field(default_factory=PlayerActorStruct)
flags_player_actor: int = dataclasses.field(default=16388) # Flagset
render_gun_override: int = dataclasses.field(default=0)
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 'PLAC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00"') # 34 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@^R\x86') # 0x405e5286
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.no_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'\xc0\x8d\x1b\x93') # 0xc08d1b93
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_loop))
data.write(b'\x1e2R>') # 0x1e32523e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.immovable))
data.write(b'\x1d\x8d\xd8F') # 0x1d8dd846
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_solid))
data.write(b'\x84c\x97\xa8') # 0x846397a8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.empty_suit_model))
data.write(b'hZL\x01') # 0x685a4c01
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.empty_suit_skin_rule))
data.write(b'\x984\xec\xc9') # 0x9834ecc9
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.varia_suit_model))
data.write(b'\x18\x8b\x89`') # 0x188b8960
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.varia_suit_skin_rule))
data.write(b'\x13J\x81\xe3') # 0x134a81e3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.varia_suit_grapple_model))
data.write(b'J\xbf\x03\x0c') # 0x4abf030c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.varia_suit_grapple_skin_rule))
data.write(b'\x9b\xf00\xdc') # 0x9bf030dc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage01_suit_model))
data.write(b'\x98\x12c\xd3') # 0x981263d3
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage01_skin_rule))
data.write(b'\x8a\x8dZ\xa5') # 0x8a8d5aa5
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage02_suit_model))
data.write(b'\xe4sF\x08') # 0xe4734608
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage02_skin_rule))
data.write(b'3v\x81M') # 0x3376814d
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage03_suit_model))
data.write(b'y|\xa7~') # 0x797ca77e
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage03_skin_rule))
data.write(b'\x0e\xbe\xc4@') # 0xebec440
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage03_acid_model))
data.write(b'\xbc\tR\xd8') # 0xbc0952d8
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage03_acid_rule))
data.write(b'\xa8w\x8eW') # 0xa8778e57
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage04_suit_model))
data.write(b'\x1c\xb1\r\xbe') # 0x1cb10dbe
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.stage04_skin_rule))
data.write(b'\x10\x98\xd0\x91') # 0x1098d091
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_actor_struct_0x1098d091.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc78S\x90') # 0xc7385390
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.player_actor_struct_0xc7385390.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3Py\x98') # 0x33507998
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_player_actor))
data.write(b'\xb6\x83(@') # 0xb6832840
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_gun_override))
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']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
mass=data['mass'],
gravity=data['gravity'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
no_model=data['no_model'],
animation=AnimationParameters.from_json(data['animation']),
actor_information=ActorParameters.from_json(data['actor_information']),
is_loop=data['is_loop'],
immovable=data['immovable'],
is_solid=data['is_solid'],
empty_suit_model=data['empty_suit_model'],
empty_suit_skin_rule=data['empty_suit_skin_rule'],
varia_suit_model=data['varia_suit_model'],
varia_suit_skin_rule=data['varia_suit_skin_rule'],
varia_suit_grapple_model=data['varia_suit_grapple_model'],
varia_suit_grapple_skin_rule=data['varia_suit_grapple_skin_rule'],
stage01_suit_model=data['stage01_suit_model'],
stage01_skin_rule=data['stage01_skin_rule'],
stage02_suit_model=data['stage02_suit_model'],
stage02_skin_rule=data['stage02_skin_rule'],
stage03_suit_model=data['stage03_suit_model'],
stage03_skin_rule=data['stage03_skin_rule'],
stage03_acid_model=data['stage03_acid_model'],
stage03_acid_rule=data['stage03_acid_rule'],
stage04_suit_model=data['stage04_suit_model'],
stage04_skin_rule=data['stage04_skin_rule'],
player_actor_struct_0x1098d091=PlayerActorStruct.from_json(data['player_actor_struct_0x1098d091']),
player_actor_struct_0xc7385390=PlayerActorStruct.from_json(data['player_actor_struct_0xc7385390']),
flags_player_actor=data['flags_player_actor'],
render_gun_override=data['render_gun_override'],
unknown_struct510=ShadowProjection.from_json(data['unknown_struct510']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'mass': self.mass,
'gravity': self.gravity,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'no_model': self.no_model,
'animation': self.animation.to_json(),
'actor_information': self.actor_information.to_json(),
'is_loop': self.is_loop,
'immovable': self.immovable,
'is_solid': self.is_solid,
'empty_suit_model': self.empty_suit_model,
'empty_suit_skin_rule': self.empty_suit_skin_rule,
'varia_suit_model': self.varia_suit_model,
'varia_suit_skin_rule': self.varia_suit_skin_rule,
'varia_suit_grapple_model': self.varia_suit_grapple_model,
'varia_suit_grapple_skin_rule': self.varia_suit_grapple_skin_rule,
'stage01_suit_model': self.stage01_suit_model,
'stage01_skin_rule': self.stage01_skin_rule,
'stage02_suit_model': self.stage02_suit_model,
'stage02_skin_rule': self.stage02_skin_rule,
'stage03_suit_model': self.stage03_suit_model,
'stage03_skin_rule': self.stage03_skin_rule,
'stage03_acid_model': self.stage03_acid_model,
'stage03_acid_rule': self.stage03_acid_rule,
'stage04_suit_model': self.stage04_suit_model,
'stage04_skin_rule': self.stage04_skin_rule,
'player_actor_struct_0x1098d091': self.player_actor_struct_0x1098d091.to_json(),
'player_actor_struct_0xc7385390': self.player_actor_struct_0xc7385390.to_json(),
'flags_player_actor': self.flags_player_actor,
'render_gun_override': self.render_gun_override,
'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_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gravity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_health(data: typing.BinaryIO, property_size: int):
return HealthInfo.from_stream(data, property_size)
def _decode_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_no_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_is_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_immovable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_solid(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_empty_suit_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_empty_suit_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_varia_suit_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_varia_suit_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_varia_suit_grapple_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_varia_suit_grapple_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage01_suit_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage01_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage02_suit_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage02_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage03_suit_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage03_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage03_acid_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage03_acid_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage04_suit_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_stage04_skin_rule(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_player_actor_struct_0x1098d091(data: typing.BinaryIO, property_size: int):
return PlayerActorStruct.from_stream(data, property_size)
def _decode_player_actor_struct_0xc7385390(data: typing.BinaryIO, property_size: int):
return PlayerActorStruct.from_stream(data, property_size)
def _decode_flags_player_actor(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_render_gun_override(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),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0x75dbb375: ('mass', _decode_mass),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x405e5286: ('no_model', _decode_no_model),
0xa3d63f44: ('animation', _decode_animation),
0x7e397fed: ('actor_information', _decode_actor_information),
0xc08d1b93: ('is_loop', _decode_is_loop),
0x1e32523e: ('immovable', _decode_immovable),
0x1d8dd846: ('is_solid', _decode_is_solid),
0x846397a8: ('empty_suit_model', _decode_empty_suit_model),
0x685a4c01: ('empty_suit_skin_rule', _decode_empty_suit_skin_rule),
0x9834ecc9: ('varia_suit_model', _decode_varia_suit_model),
0x188b8960: ('varia_suit_skin_rule', _decode_varia_suit_skin_rule),
0x134a81e3: ('varia_suit_grapple_model', _decode_varia_suit_grapple_model),
0x4abf030c: ('varia_suit_grapple_skin_rule', _decode_varia_suit_grapple_skin_rule),
0x9bf030dc: ('stage01_suit_model', _decode_stage01_suit_model),
0x981263d3: ('stage01_skin_rule', _decode_stage01_skin_rule),
0x8a8d5aa5: ('stage02_suit_model', _decode_stage02_suit_model),
0xe4734608: ('stage02_skin_rule', _decode_stage02_skin_rule),
0x3376814d: ('stage03_suit_model', _decode_stage03_suit_model),
0x797ca77e: ('stage03_skin_rule', _decode_stage03_skin_rule),
0xebec440: ('stage03_acid_model', _decode_stage03_acid_model),
0xbc0952d8: ('stage03_acid_rule', _decode_stage03_acid_rule),
0xa8778e57: ('stage04_suit_model', _decode_stage04_suit_model),
0x1cb10dbe: ('stage04_skin_rule', _decode_stage04_skin_rule),
0x1098d091: ('player_actor_struct_0x1098d091', _decode_player_actor_struct_0x1098d091),
0xc7385390: ('player_actor_struct_0xc7385390', _decode_player_actor_struct_0xc7385390),
0x33507998: ('flags_player_actor', _decode_flags_player_actor),
0xb6832840: ('render_gun_override', _decode_render_gun_override),
0xa21b515a: ('unknown_struct510', _decode_unknown_struct510),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PlayerActor.py | 0.606265 | 0.160135 | PlayerActor.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.FlyingPirateData import FlyingPirateData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class FlyingPirate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
flying_pirate_properties: FlyingPirateData = dataclasses.field(default_factory=FlyingPirateData)
@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 'FLYP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_FlyingPirate.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"\xb3'\xe8\x03") # 0xb327e803
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flying_pirate_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']),
flying_pirate_properties=FlyingPirateData.from_json(data['flying_pirate_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(),
'flying_pirate_properties': self.flying_pirate_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, 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_flying_pirate_properties(data: typing.BinaryIO, property_size: int):
return FlyingPirateData.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),
0xb327e803: ('flying_pirate_properties', _decode_flying_pirate_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FlyingPirate.py | 0.625896 | 0.323073 | FlyingPirate.py | 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 SkyRipple(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 'SKRP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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/SkyRipple.py | 0.583678 | 0.342365 | SkyRipple.py | 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.LightParameters import LightParameters
from retro_data_structures.properties.corruption.archetypes.SplineType import SplineType
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class Effect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART', 'ELSC', 'SPSC', 'SWHC']}, default=default_asset_id)
auto_start: bool = dataclasses.field(default=True)
unknown_0x3df5a489: bool = dataclasses.field(default=False)
unknown_0x08349bd6: bool = dataclasses.field(default=False)
unknown_0xee538174: bool = dataclasses.field(default=False)
unknown_0xa94b0efd: float = dataclasses.field(default=5.0)
unknown_0x93756968: float = dataclasses.field(default=0.5)
unknown_0x0b94597d: float = dataclasses.field(default=0.20000000298023224)
unknown_0xd0e8a496: float = dataclasses.field(default=0.10000000149011612)
unknown_0xa8bb6c61: bool = dataclasses.field(default=False)
unknown_0x7589d549: float = dataclasses.field(default=20.0)
unknown_0xa7d7d767: float = dataclasses.field(default=30.0)
unknown_0xfe69615c: float = dataclasses.field(default=0.0)
unknown_0x84368d03: float = dataclasses.field(default=5.0)
unknown_0xa559c066: float = dataclasses.field(default=10.0)
visible_in_normal: bool = dataclasses.field(default=True)
visible_in_x_ray: bool = dataclasses.field(default=True)
unknown_0x6714021c: bool = dataclasses.field(default=True)
unknown_0xbe931927: bool = dataclasses.field(default=False)
render_order: int = dataclasses.field(default=0)
lighting: LightParameters = dataclasses.field(default_factory=LightParameters)
unknown_0x4d55f7d4: bool = dataclasses.field(default=False)
motion_spline_path_loops: bool = dataclasses.field(default=False)
motion_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
motion_spline_duration: float = dataclasses.field(default=10.0)
unknown_0x73e63382: bool = dataclasses.field(default=False)
unknown_0x608ecac5: bool = dataclasses.field(default=False)
@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 'EFCT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1d') # 29 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\nG\x9do') # 0xa479d6f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.particle_effect))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'=\xf5\xa4\x89') # 0x3df5a489
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x3df5a489))
data.write(b'\x084\x9b\xd6') # 0x8349bd6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x08349bd6))
data.write(b'\xeeS\x81t') # 0xee538174
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xee538174))
data.write(b'\xa9K\x0e\xfd') # 0xa94b0efd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa94b0efd))
data.write(b'\x93uih') # 0x93756968
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x93756968))
data.write(b'\x0b\x94Y}') # 0xb94597d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0b94597d))
data.write(b'\xd0\xe8\xa4\x96') # 0xd0e8a496
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd0e8a496))
data.write(b'\xa8\xbbla') # 0xa8bb6c61
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xa8bb6c61))
data.write(b'u\x89\xd5I') # 0x7589d549
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7589d549))
data.write(b'\xa7\xd7\xd7g') # 0xa7d7d767
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa7d7d767))
data.write(b'\xfeia\\') # 0xfe69615c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfe69615c))
data.write(b'\x846\x8d\x03') # 0x84368d03
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x84368d03))
data.write(b'\xa5Y\xc0f') # 0xa559c066
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa559c066))
data.write(b'6\x8b\xf2E') # 0x368bf245
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.visible_in_normal))
data.write(b'\xef\xff\xa3\xbe') # 0xefffa3be
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.visible_in_x_ray))
data.write(b'g\x14\x02\x1c') # 0x6714021c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x6714021c))
data.write(b"\xbe\x93\x19'") # 0xbe931927
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbe931927))
data.write(b'/\xa4\xe5\xd7') # 0x2fa4e5d7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.render_order))
data.write(b'\xb0(\xdb\x0e') # 0xb028db0e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'MU\xf7\xd4') # 0x4d55f7d4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4d55f7d4))
data.write(b'=t\x06\xaf') # 0x3d7406af
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.motion_spline_path_loops))
data.write(b'I=j-') # 0x493d6a2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfd\x1e/V') # 0xfd1e2f56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.motion_spline_duration))
data.write(b's\xe63\x82') # 0x73e63382
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x73e63382))
data.write(b'`\x8e\xca\xc5') # 0x608ecac5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x608ecac5))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
particle_effect=data['particle_effect'],
auto_start=data['auto_start'],
unknown_0x3df5a489=data['unknown_0x3df5a489'],
unknown_0x08349bd6=data['unknown_0x08349bd6'],
unknown_0xee538174=data['unknown_0xee538174'],
unknown_0xa94b0efd=data['unknown_0xa94b0efd'],
unknown_0x93756968=data['unknown_0x93756968'],
unknown_0x0b94597d=data['unknown_0x0b94597d'],
unknown_0xd0e8a496=data['unknown_0xd0e8a496'],
unknown_0xa8bb6c61=data['unknown_0xa8bb6c61'],
unknown_0x7589d549=data['unknown_0x7589d549'],
unknown_0xa7d7d767=data['unknown_0xa7d7d767'],
unknown_0xfe69615c=data['unknown_0xfe69615c'],
unknown_0x84368d03=data['unknown_0x84368d03'],
unknown_0xa559c066=data['unknown_0xa559c066'],
visible_in_normal=data['visible_in_normal'],
visible_in_x_ray=data['visible_in_x_ray'],
unknown_0x6714021c=data['unknown_0x6714021c'],
unknown_0xbe931927=data['unknown_0xbe931927'],
render_order=data['render_order'],
lighting=LightParameters.from_json(data['lighting']),
unknown_0x4d55f7d4=data['unknown_0x4d55f7d4'],
motion_spline_path_loops=data['motion_spline_path_loops'],
motion_spline_type=SplineType.from_json(data['motion_spline_type']),
motion_control_spline=Spline.from_json(data['motion_control_spline']),
motion_spline_duration=data['motion_spline_duration'],
unknown_0x73e63382=data['unknown_0x73e63382'],
unknown_0x608ecac5=data['unknown_0x608ecac5'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'particle_effect': self.particle_effect,
'auto_start': self.auto_start,
'unknown_0x3df5a489': self.unknown_0x3df5a489,
'unknown_0x08349bd6': self.unknown_0x08349bd6,
'unknown_0xee538174': self.unknown_0xee538174,
'unknown_0xa94b0efd': self.unknown_0xa94b0efd,
'unknown_0x93756968': self.unknown_0x93756968,
'unknown_0x0b94597d': self.unknown_0x0b94597d,
'unknown_0xd0e8a496': self.unknown_0xd0e8a496,
'unknown_0xa8bb6c61': self.unknown_0xa8bb6c61,
'unknown_0x7589d549': self.unknown_0x7589d549,
'unknown_0xa7d7d767': self.unknown_0xa7d7d767,
'unknown_0xfe69615c': self.unknown_0xfe69615c,
'unknown_0x84368d03': self.unknown_0x84368d03,
'unknown_0xa559c066': self.unknown_0xa559c066,
'visible_in_normal': self.visible_in_normal,
'visible_in_x_ray': self.visible_in_x_ray,
'unknown_0x6714021c': self.unknown_0x6714021c,
'unknown_0xbe931927': self.unknown_0xbe931927,
'render_order': self.render_order,
'lighting': self.lighting.to_json(),
'unknown_0x4d55f7d4': self.unknown_0x4d55f7d4,
'motion_spline_path_loops': self.motion_spline_path_loops,
'motion_spline_type': self.motion_spline_type.to_json(),
'motion_control_spline': self.motion_control_spline.to_json(),
'motion_spline_duration': self.motion_spline_duration,
'unknown_0x73e63382': self.unknown_0x73e63382,
'unknown_0x608ecac5': self.unknown_0x608ecac5,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x3df5a489(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x08349bd6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xee538174(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa94b0efd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x93756968(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0b94597d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd0e8a496(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa8bb6c61(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7589d549(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa7d7d767(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfe69615c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x84368d03(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa559c066(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visible_in_normal(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_visible_in_x_ray(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x6714021c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbe931927(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_render_order(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightParameters.from_stream(data, property_size)
def _decode_unknown_0x4d55f7d4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_path_loops(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_motion_spline_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x73e63382(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x608ecac5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa479d6f: ('particle_effect', _decode_particle_effect),
0x3217dff8: ('auto_start', _decode_auto_start),
0x3df5a489: ('unknown_0x3df5a489', _decode_unknown_0x3df5a489),
0x8349bd6: ('unknown_0x08349bd6', _decode_unknown_0x08349bd6),
0xee538174: ('unknown_0xee538174', _decode_unknown_0xee538174),
0xa94b0efd: ('unknown_0xa94b0efd', _decode_unknown_0xa94b0efd),
0x93756968: ('unknown_0x93756968', _decode_unknown_0x93756968),
0xb94597d: ('unknown_0x0b94597d', _decode_unknown_0x0b94597d),
0xd0e8a496: ('unknown_0xd0e8a496', _decode_unknown_0xd0e8a496),
0xa8bb6c61: ('unknown_0xa8bb6c61', _decode_unknown_0xa8bb6c61),
0x7589d549: ('unknown_0x7589d549', _decode_unknown_0x7589d549),
0xa7d7d767: ('unknown_0xa7d7d767', _decode_unknown_0xa7d7d767),
0xfe69615c: ('unknown_0xfe69615c', _decode_unknown_0xfe69615c),
0x84368d03: ('unknown_0x84368d03', _decode_unknown_0x84368d03),
0xa559c066: ('unknown_0xa559c066', _decode_unknown_0xa559c066),
0x368bf245: ('visible_in_normal', _decode_visible_in_normal),
0xefffa3be: ('visible_in_x_ray', _decode_visible_in_x_ray),
0x6714021c: ('unknown_0x6714021c', _decode_unknown_0x6714021c),
0xbe931927: ('unknown_0xbe931927', _decode_unknown_0xbe931927),
0x2fa4e5d7: ('render_order', _decode_render_order),
0xb028db0e: ('lighting', _decode_lighting),
0x4d55f7d4: ('unknown_0x4d55f7d4', _decode_unknown_0x4d55f7d4),
0x3d7406af: ('motion_spline_path_loops', _decode_motion_spline_path_loops),
0x493d6a2d: ('motion_spline_type', _decode_motion_spline_type),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xfd1e2f56: ('motion_spline_duration', _decode_motion_spline_duration),
0x73e63382: ('unknown_0x73e63382', _decode_unknown_0x73e63382),
0x608ecac5: ('unknown_0x608ecac5', _decode_unknown_0x608ecac5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Effect.py | 0.607663 | 0.240858 | Effect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class EnvFxDensityController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
density: float = dataclasses.field(default=0.5)
fade_speed: int = dataclasses.field(default=500)
@classmethod
def game(cls) -> Game:
return Game.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 'FXDC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xe5\xfe\x9f') # 0x64e5fe9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.density))
data.write(b'e\xa8#\xb4') # 0x65a823b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.fade_speed))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
density=data['density'],
fade_speed=data['fade_speed'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'density': self.density,
'fade_speed': self.fade_speed,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x64e5fe9f: ('density', _decode_density),
0x65a823b4: ('fade_speed', _decode_fade_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/EnvFxDensityController.py | 0.648578 | 0.347399 | EnvFxDensityController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.corruption as enums
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.Spline import Spline
@dataclasses.dataclass()
class ColorModulate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
color_a: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
color_b: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
blend_mode: enums.Blend_Mode = dataclasses.field(default=enums.Blend_Mode.Unknown1)
time_a2_b: float = dataclasses.field(default=1.0)
time_b2_a: float = dataclasses.field(default=1.0)
do_reverse: bool = dataclasses.field(default=False)
reset_target_when_done: bool = dataclasses.field(default=False)
depth_compare: bool = dataclasses.field(default=True)
depth_update: bool = dataclasses.field(default=True)
depth_backwards: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
update_time: bool = dataclasses.field(default=True)
loop_forever: bool = dataclasses.field(default=False)
external_time: bool = dataclasses.field(default=False)
copy_model_color_to_color_a: bool = dataclasses.field(default=False)
write_depth_first: bool = dataclasses.field(default=False)
control_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.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 'CLRM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x12') # 18 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd6\xa3\xd2o') # 0xd6a3d26f
data.write(b'\x00\x10') # size
self.color_a.to_stream(data)
data.write(b'P7\xa0\xc1') # 0x5037a0c1
data.write(b'\x00\x10') # size
self.color_b.to_stream(data)
data.write(b'\xffEuF') # 0xff457546
data.write(b'\x00\x04') # size
self.blend_mode.to_stream(data)
data.write(b'\x1a\xfa\\H') # 0x1afa5c48
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_a2_b))
data.write(b'\x12\xe1)\x05') # 0x12e12905
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_b2_a))
data.write(b'\xce\xc5$K') # 0xcec5244b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.do_reverse))
data.write(b'\x81\xfc\x97\x9c') # 0x81fc979c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.reset_target_when_done))
data.write(b'\x94\xc0\x1b\x0c') # 0x94c01b0c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_compare))
data.write(b'\xae\xd2ZQ') # 0xaed25a51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_update))
data.write(b'5\xdcC\xd0') # 0x35dc43d0
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.depth_backwards))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b':\x7fY\xf7') # 0x3a7f59f7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.update_time))
data.write(b'\x08\xbbs\xc5') # 0x8bb73c5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop_forever))
data.write(b'~7\x9a\xe8') # 0x7e379ae8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.external_time))
data.write(b't\x08\x1e\x94') # 0x74081e94
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.copy_model_color_to_color_a))
data.write(b'\x9a0g@') # 0x9a306740
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.write_depth_first))
data.write(b'\x15V\x7f\xe7') # 0x15567fe7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
color_a=Color.from_json(data['color_a']),
color_b=Color.from_json(data['color_b']),
blend_mode=enums.Blend_Mode.from_json(data['blend_mode']),
time_a2_b=data['time_a2_b'],
time_b2_a=data['time_b2_a'],
do_reverse=data['do_reverse'],
reset_target_when_done=data['reset_target_when_done'],
depth_compare=data['depth_compare'],
depth_update=data['depth_update'],
depth_backwards=data['depth_backwards'],
auto_start=data['auto_start'],
update_time=data['update_time'],
loop_forever=data['loop_forever'],
external_time=data['external_time'],
copy_model_color_to_color_a=data['copy_model_color_to_color_a'],
write_depth_first=data['write_depth_first'],
control_spline=Spline.from_json(data['control_spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'color_a': self.color_a.to_json(),
'color_b': self.color_b.to_json(),
'blend_mode': self.blend_mode.to_json(),
'time_a2_b': self.time_a2_b,
'time_b2_a': self.time_b2_a,
'do_reverse': self.do_reverse,
'reset_target_when_done': self.reset_target_when_done,
'depth_compare': self.depth_compare,
'depth_update': self.depth_update,
'depth_backwards': self.depth_backwards,
'auto_start': self.auto_start,
'update_time': self.update_time,
'loop_forever': self.loop_forever,
'external_time': self.external_time,
'copy_model_color_to_color_a': self.copy_model_color_to_color_a,
'write_depth_first': self.write_depth_first,
'control_spline': self.control_spline.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_color_a(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_color_b(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return enums.Blend_Mode.from_stream(data)
def _decode_time_a2_b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_b2_a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_do_reverse(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_reset_target_when_done(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_compare(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_update(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_depth_backwards(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_update_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_forever(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_external_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_copy_model_color_to_color_a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_write_depth_first(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd6a3d26f: ('color_a', _decode_color_a),
0x5037a0c1: ('color_b', _decode_color_b),
0xff457546: ('blend_mode', _decode_blend_mode),
0x1afa5c48: ('time_a2_b', _decode_time_a2_b),
0x12e12905: ('time_b2_a', _decode_time_b2_a),
0xcec5244b: ('do_reverse', _decode_do_reverse),
0x81fc979c: ('reset_target_when_done', _decode_reset_target_when_done),
0x94c01b0c: ('depth_compare', _decode_depth_compare),
0xaed25a51: ('depth_update', _decode_depth_update),
0x35dc43d0: ('depth_backwards', _decode_depth_backwards),
0x3217dff8: ('auto_start', _decode_auto_start),
0x3a7f59f7: ('update_time', _decode_update_time),
0x8bb73c5: ('loop_forever', _decode_loop_forever),
0x7e379ae8: ('external_time', _decode_external_time),
0x74081e94: ('copy_model_color_to_color_a', _decode_copy_model_color_to_color_a),
0x9a306740: ('write_depth_first', _decode_write_depth_first),
0x15567fe7: ('control_spline', _decode_control_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ColorModulate.py | 0.560974 | 0.300335 | ColorModulate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class AVIS(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
visualization_file: AssetId = dataclasses.field(metadata={'asset_types': ['CAAD']}, default=default_asset_id)
texture_file: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, 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 'AVIS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2Ulf') # 0xb2556c66
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.visualization_file))
data.write(b'B\tv\x86') # 0x42097686
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.texture_file))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
visualization_file=data['visualization_file'],
texture_file=data['texture_file'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'visualization_file': self.visualization_file,
'texture_file': self.texture_file,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_visualization_file(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_texture_file(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb2556c66: ('visualization_file', _decode_visualization_file),
0x42097686: ('texture_file', _decode_texture_file),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AVIS.py | 0.574634 | 0.313683 | AVIS.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ActorMorph(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0xc60575f5: float = dataclasses.field(default=0.5)
unknown_0xe9fe0baa: float = dataclasses.field(default=0.5)
unknown_0x8e79a0fb: float = dataclasses.field(default=0.10000000149011612)
unknown_0xa182dea4: float = dataclasses.field(default=0.10000000149011612)
key_points: str = dataclasses.field(default='')
unknown_0x8bd0e337: float = dataclasses.field(default=1.0)
unknown_0x39427691: 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 'AMOR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptActorMorph.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'\xc6\x05u\xf5') # 0xc60575f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc60575f5))
data.write(b'\xe9\xfe\x0b\xaa') # 0xe9fe0baa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe9fe0baa))
data.write(b'\x8ey\xa0\xfb') # 0x8e79a0fb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8e79a0fb))
data.write(b'\xa1\x82\xde\xa4') # 0xa182dea4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa182dea4))
data.write(b'\x95\xde\xbd\x1b') # 0x95debd1b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.key_points.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8b\xd0\xe37') # 0x8bd0e337
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8bd0e337))
data.write(b'9Bv\x91') # 0x39427691
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x39427691))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_0xc60575f5=data['unknown_0xc60575f5'],
unknown_0xe9fe0baa=data['unknown_0xe9fe0baa'],
unknown_0x8e79a0fb=data['unknown_0x8e79a0fb'],
unknown_0xa182dea4=data['unknown_0xa182dea4'],
key_points=data['key_points'],
unknown_0x8bd0e337=data['unknown_0x8bd0e337'],
unknown_0x39427691=data['unknown_0x39427691'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0xc60575f5': self.unknown_0xc60575f5,
'unknown_0xe9fe0baa': self.unknown_0xe9fe0baa,
'unknown_0x8e79a0fb': self.unknown_0x8e79a0fb,
'unknown_0xa182dea4': self.unknown_0xa182dea4,
'key_points': self.key_points,
'unknown_0x8bd0e337': self.unknown_0x8bd0e337,
'unknown_0x39427691': self.unknown_0x39427691,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0xc60575f5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe9fe0baa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8e79a0fb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa182dea4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_key_points(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown_0x8bd0e337(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x39427691(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),
0xc60575f5: ('unknown_0xc60575f5', _decode_unknown_0xc60575f5),
0xe9fe0baa: ('unknown_0xe9fe0baa', _decode_unknown_0xe9fe0baa),
0x8e79a0fb: ('unknown_0x8e79a0fb', _decode_unknown_0x8e79a0fb),
0xa182dea4: ('unknown_0xa182dea4', _decode_unknown_0xa182dea4),
0x95debd1b: ('key_points', _decode_key_points),
0x8bd0e337: ('unknown_0x8bd0e337', _decode_unknown_0x8bd0e337),
0x39427691: ('unknown_0x39427691', _decode_unknown_0x39427691),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ActorMorph.py | 0.605099 | 0.277222 | ActorMorph.py | 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.GunTurretTopData import GunTurretTopData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class GunTurretTop(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gun_turret_top_data: GunTurretTopData = dataclasses.field(default_factory=GunTurretTopData)
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 'GNTT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_GunTurret.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'\xa8X\xf4\xe7') # 0xa858f4e7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gun_turret_top_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={'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']),
gun_turret_top_data=GunTurretTopData.from_json(data['gun_turret_top_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(),
'gun_turret_top_data': self.gun_turret_top_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_gun_turret_top_data(data: typing.BinaryIO, property_size: int):
return GunTurretTopData.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),
0xa858f4e7: ('gun_turret_top_data', _decode_gun_turret_top_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/GunTurretTop.py | 0.61832 | 0.302108 | GunTurretTop.py | 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 CrossAreaRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
relay_name: str = dataclasses.field(default='')
@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 'CRAR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xd2\xeb\x00\x9d') # 0xd2eb009d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.relay_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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
relay_name=data['relay_name'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'relay_name': self.relay_name,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_relay_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xd2eb009d: ('relay_name', _decode_relay_name),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CrossAreaRelay.py | 0.585812 | 0.353317 | CrossAreaRelay.py | 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.DamageInfo import DamageInfo
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 EffectRepulsor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
item: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
zap_time: float = dataclasses.field(default=0.10000000149011612)
retrigger_time: float = dataclasses.field(default=0.10000000149011612)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
@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 'EFTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xa1i\xd4$') # 0xa169d424
data.write(b'\x00\x04') # size
self.item.to_stream(data)
data.write(b'\xb6\x8cm\x96') # 0xb68c6d96
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.effect))
data.write(b'h\xb0\xf63') # 0x68b0f633
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.zap_time))
data.write(b'\xa8\xe3\xaf\xf1') # 0xa8e3aff1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.retrigger_time))
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data, default_override={'di_knock_back_power': 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']),
item=enums.PlayerItem.from_json(data['item']),
effect=data['effect'],
zap_time=data['zap_time'],
retrigger_time=data['retrigger_time'],
damage=DamageInfo.from_json(data['damage']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'item': self.item.to_json(),
'effect': self.effect,
'zap_time': self.zap_time,
'retrigger_time': self.retrigger_time,
'damage': self.damage.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_item(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_zap_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_retrigger_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_knock_back_power': 1.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xa169d424: ('item', _decode_item),
0xb68c6d96: ('effect', _decode_effect),
0x68b0f633: ('zap_time', _decode_zap_time),
0xa8e3aff1: ('retrigger_time', _decode_retrigger_time),
0x337f9524: ('damage', _decode_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/EffectRepulsor.py | 0.566738 | 0.257514 | EffectRepulsor.py | 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
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class WorldTeleporter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
world: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
area: AssetId = dataclasses.field(metadata={'asset_types': ['MREA']}, default=default_asset_id)
type: enums.Type = dataclasses.field(default=enums.Type.Unknown1)
ship: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
camera: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
skybox: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
char_0x05014c61: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0xf9ef55d4: Spline = dataclasses.field(default_factory=Spline)
char_0x3c79e121: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
unknown_0x8e718724: Spline = dataclasses.field(default_factory=Spline)
display_font: AssetId = dataclasses.field(metadata={'asset_types': ['FONT']}, default=default_asset_id)
string: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
is_fade_white: bool = dataclasses.field(default=False)
character_fade_time: float = dataclasses.field(default=0.009999999776482582)
characters_per_second: float = dataclasses.field(default=8.0)
start_delay: float = dataclasses.field(default=0.0)
audio_stream: str = dataclasses.field(default='')
display_subtitles: bool = dataclasses.field(default=False)
end_delay: float = dataclasses.field(default=0.0)
subtitle_fade_in_delay: float = dataclasses.field(default=2.0)
subtitle_fade_time: float = dataclasses.field(default=3.0)
from_skybox: str = dataclasses.field(default='')
from_ship: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
from_camera: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
to_skybox: str = dataclasses.field(default='')
to_ship: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
to_camera: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
ship_grapple: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
transition_sound: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
volume: float = dataclasses.field(default=1.0)
pan: float = dataclasses.field(default=0.0)
transition_sound2: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
volume2: float = dataclasses.field(default=1.0)
pan2: float = dataclasses.field(default=0.0)
unknown_0x5657ca1c: bool = dataclasses.field(default=False)
min_transition_time: float = dataclasses.field(default=5.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 'TEL1'
@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%') # 37 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'1\xec\x14\xbc') # 0x31ec14bc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.world))
data.write(b'\xe0\xc1x\x04') # 0xe0c17804
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.area))
data.write(b'GK\xcc\xe3') # 0x474bcce3
data.write(b'\x00\x04') # size
self.type.to_stream(data)
data.write(b'\xa9IeQ') # 0xa9496551
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ship.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbb\xefM\r') # 0xbbef4d0d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc\xef\xc6\x18') # 0xccefc618
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.skybox))
data.write(b'\x05\x01La') # 0x5014c61
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char_0x05014c61.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf9\xefU\xd4') # 0xf9ef55d4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xf9ef55d4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<y\xe1!') # 0x3c79e121
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.char_0x3c79e121.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8eq\x87$') # 0x8e718724
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x8e718724.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l\x17m\xd6') # 0x6c176dd6
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.display_font))
data.write(b'\x91\x82%\x0c') # 0x9182250c
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.string))
data.write(b'\xc5@\x82\xe8') # 0xc54082e8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_fade_white))
data.write(b'\xd9\xb29O') # 0xd9b2394f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.character_fade_time))
data.write(b'55\x82\xbd') # 0x353582bd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.characters_per_second))
data.write(b'\x19n\x17\xd9') # 0x196e17d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.start_delay))
data.write(b'\xb2\x8f7\xb1') # 0xb28f37b1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.audio_stream.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'\xa1\xc4\xe7\xf8') # 0xa1c4e7f8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.display_subtitles))
data.write(b'y\xcd\xa5|') # 0x79cda57c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.end_delay))
data.write(b'\x0bR@\xe3') # 0xb5240e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.subtitle_fade_in_delay))
data.write(b'qxg\x11') # 0x71786711
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.subtitle_fade_time))
data.write(b'.&p-') # 0x2e26702d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.from_skybox.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'S\x96:h') # 0x53963a68
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.from_ship.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'N\xbfv\r') # 0x4ebf760d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.from_camera.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\x93\x05s') # 0x61930573
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.to_skybox.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']~y\xa1') # 0x5d7e79a1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.to_ship.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbbR\x04\xc8') # 0xbb5204c8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.to_camera.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb7\xdc\xd0\xca') # 0xb7dcd0ca
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.ship_grapple))
data.write(b'\x04\xd0>A') # 0x4d03e41
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.transition_sound))
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'\xdfCS\xa3') # 0xdf4353a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan))
data.write(b'\x8d\xffVt') # 0x8dff5674
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.transition_sound2))
data.write(b'1\xfa\x1f\xe0') # 0x31fa1fe0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume2))
data.write(b'\xeaY2\x94') # 0xea593294
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan2))
data.write(b'VW\xca\x1c') # 0x5657ca1c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5657ca1c))
data.write(b'\xbdj@m') # 0xbd6a406d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_transition_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']),
world=data['world'],
area=data['area'],
type=enums.Type.from_json(data['type']),
ship=AnimationParameters.from_json(data['ship']),
camera=AnimationParameters.from_json(data['camera']),
skybox=data['skybox'],
char_0x05014c61=AnimationParameters.from_json(data['char_0x05014c61']),
unknown_0xf9ef55d4=Spline.from_json(data['unknown_0xf9ef55d4']),
char_0x3c79e121=AnimationParameters.from_json(data['char_0x3c79e121']),
unknown_0x8e718724=Spline.from_json(data['unknown_0x8e718724']),
display_font=data['display_font'],
string=data['string'],
is_fade_white=data['is_fade_white'],
character_fade_time=data['character_fade_time'],
characters_per_second=data['characters_per_second'],
start_delay=data['start_delay'],
audio_stream=data['audio_stream'],
display_subtitles=data['display_subtitles'],
end_delay=data['end_delay'],
subtitle_fade_in_delay=data['subtitle_fade_in_delay'],
subtitle_fade_time=data['subtitle_fade_time'],
from_skybox=data['from_skybox'],
from_ship=AnimationParameters.from_json(data['from_ship']),
from_camera=AnimationParameters.from_json(data['from_camera']),
to_skybox=data['to_skybox'],
to_ship=AnimationParameters.from_json(data['to_ship']),
to_camera=AnimationParameters.from_json(data['to_camera']),
ship_grapple=data['ship_grapple'],
transition_sound=data['transition_sound'],
volume=data['volume'],
pan=data['pan'],
transition_sound2=data['transition_sound2'],
volume2=data['volume2'],
pan2=data['pan2'],
unknown_0x5657ca1c=data['unknown_0x5657ca1c'],
min_transition_time=data['min_transition_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'world': self.world,
'area': self.area,
'type': self.type.to_json(),
'ship': self.ship.to_json(),
'camera': self.camera.to_json(),
'skybox': self.skybox,
'char_0x05014c61': self.char_0x05014c61.to_json(),
'unknown_0xf9ef55d4': self.unknown_0xf9ef55d4.to_json(),
'char_0x3c79e121': self.char_0x3c79e121.to_json(),
'unknown_0x8e718724': self.unknown_0x8e718724.to_json(),
'display_font': self.display_font,
'string': self.string,
'is_fade_white': self.is_fade_white,
'character_fade_time': self.character_fade_time,
'characters_per_second': self.characters_per_second,
'start_delay': self.start_delay,
'audio_stream': self.audio_stream,
'display_subtitles': self.display_subtitles,
'end_delay': self.end_delay,
'subtitle_fade_in_delay': self.subtitle_fade_in_delay,
'subtitle_fade_time': self.subtitle_fade_time,
'from_skybox': self.from_skybox,
'from_ship': self.from_ship.to_json(),
'from_camera': self.from_camera.to_json(),
'to_skybox': self.to_skybox,
'to_ship': self.to_ship.to_json(),
'to_camera': self.to_camera.to_json(),
'ship_grapple': self.ship_grapple,
'transition_sound': self.transition_sound,
'volume': self.volume,
'pan': self.pan,
'transition_sound2': self.transition_sound2,
'volume2': self.volume2,
'pan2': self.pan2,
'unknown_0x5657ca1c': self.unknown_0x5657ca1c,
'min_transition_time': self.min_transition_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_world(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_area(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_type(data: typing.BinaryIO, property_size: int):
return enums.Type.from_stream(data)
def _decode_ship(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_camera(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_skybox(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_char_0x05014c61(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0xf9ef55d4(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_char_0x3c79e121(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_unknown_0x8e718724(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_display_font(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_string(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_is_fade_white(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_character_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_characters_per_second(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_audio_stream(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_display_subtitles(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_end_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_subtitle_fade_in_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_subtitle_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_from_skybox(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_from_ship(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_from_camera(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_to_skybox(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_to_ship(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_to_camera(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_ship_grapple(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_transition_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pan(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_transition_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_volume2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pan2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5657ca1c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_min_transition_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),
0x31ec14bc: ('world', _decode_world),
0xe0c17804: ('area', _decode_area),
0x474bcce3: ('type', _decode_type),
0xa9496551: ('ship', _decode_ship),
0xbbef4d0d: ('camera', _decode_camera),
0xccefc618: ('skybox', _decode_skybox),
0x5014c61: ('char_0x05014c61', _decode_char_0x05014c61),
0xf9ef55d4: ('unknown_0xf9ef55d4', _decode_unknown_0xf9ef55d4),
0x3c79e121: ('char_0x3c79e121', _decode_char_0x3c79e121),
0x8e718724: ('unknown_0x8e718724', _decode_unknown_0x8e718724),
0x6c176dd6: ('display_font', _decode_display_font),
0x9182250c: ('string', _decode_string),
0xc54082e8: ('is_fade_white', _decode_is_fade_white),
0xd9b2394f: ('character_fade_time', _decode_character_fade_time),
0x353582bd: ('characters_per_second', _decode_characters_per_second),
0x196e17d9: ('start_delay', _decode_start_delay),
0xb28f37b1: ('audio_stream', _decode_audio_stream),
0xa1c4e7f8: ('display_subtitles', _decode_display_subtitles),
0x79cda57c: ('end_delay', _decode_end_delay),
0xb5240e3: ('subtitle_fade_in_delay', _decode_subtitle_fade_in_delay),
0x71786711: ('subtitle_fade_time', _decode_subtitle_fade_time),
0x2e26702d: ('from_skybox', _decode_from_skybox),
0x53963a68: ('from_ship', _decode_from_ship),
0x4ebf760d: ('from_camera', _decode_from_camera),
0x61930573: ('to_skybox', _decode_to_skybox),
0x5d7e79a1: ('to_ship', _decode_to_ship),
0xbb5204c8: ('to_camera', _decode_to_camera),
0xb7dcd0ca: ('ship_grapple', _decode_ship_grapple),
0x4d03e41: ('transition_sound', _decode_transition_sound),
0xc7a7f189: ('volume', _decode_volume),
0xdf4353a3: ('pan', _decode_pan),
0x8dff5674: ('transition_sound2', _decode_transition_sound2),
0x31fa1fe0: ('volume2', _decode_volume2),
0xea593294: ('pan2', _decode_pan2),
0x5657ca1c: ('unknown_0x5657ca1c', _decode_unknown_0x5657ca1c),
0xbd6a406d: ('min_transition_time', _decode_min_transition_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/WorldTeleporter.py | 0.639286 | 0.191158 | WorldTeleporter.py | 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.ShellBugData import ShellBugData
from retro_data_structures.properties.corruption.archetypes.WallCrawlerData import WallCrawlerData
@dataclasses.dataclass()
class ShellBug(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shell_bug_data: ShellBugData = dataclasses.field(default_factory=ShellBugData)
wall_crawler_properties: WallCrawlerData = dataclasses.field(default_factory=WallCrawlerData)
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 'SHBG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ShellBug.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'\xb9\xff\xa9(') # 0xb9ffa928
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shell_bug_data.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'\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']),
shell_bug_data=ShellBugData.from_json(data['shell_bug_data']),
wall_crawler_properties=WallCrawlerData.from_json(data['wall_crawler_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(),
'shell_bug_data': self.shell_bug_data.to_json(),
'wall_crawler_properties': self.wall_crawler_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_shell_bug_data(data: typing.BinaryIO, property_size: int):
return ShellBugData.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_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),
0xb9ffa928: ('shell_bug_data', _decode_shell_bug_data),
0xb718b831: ('wall_crawler_properties', _decode_wall_crawler_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/ShellBug.py | 0.59302 | 0.326835 | ShellBug.py | 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 AVMC(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
world: AssetId = dataclasses.field(metadata={'asset_types': ['MLVL']}, default=default_asset_id)
area: int = dataclasses.field(default=2)
@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 'AVMC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'1\xec\x14\xbc') # 0x31ec14bc
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.world))
data.write(b'\xff]\x99~') # 0xff5d997e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.area))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
world=data['world'],
area=data['area'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'world': self.world,
'area': self.area,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_world(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_area(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),
0x31ec14bc: ('world', _decode_world),
0xff5d997e: ('area', _decode_area),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AVMC.py | 0.590307 | 0.328301 | AVMC.py | 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.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class ShipProxy(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation: 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 'SHPX'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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=AnimationParameters.from_json(data['animation']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation': self.animation.to_json(),
}
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 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),
0xa3d63f44: ('animation', _decode_animation),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/ShipProxy.py | 0.639849 | 0.337886 | ShipProxy.py | 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.FargullHatcherSwarmData import FargullHatcherSwarmData
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 FargullHatcherSwarm(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)
fargull_hatcher_swarm_data: FargullHatcherSwarmData = dataclasses.field(default_factory=FargullHatcherSwarmData)
@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 'FGHS'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_FargullHatcherSwarm.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'\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)
data.write(b'\x14ou\xd9') # 0x146f75d9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fargull_hatcher_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']),
fargull_hatcher_swarm_data=FargullHatcherSwarmData.from_json(data['fargull_hatcher_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(),
'fargull_hatcher_swarm_data': self.fargull_hatcher_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)
def _decode_fargull_hatcher_swarm_data(data: typing.BinaryIO, property_size: int):
return FargullHatcherSwarmData.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),
0x146f75d9: ('fargull_hatcher_swarm_data', _decode_fargull_hatcher_swarm_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/FargullHatcherSwarm.py | 0.666931 | 0.301491 | FargullHatcherSwarm.py | 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 AreaDamage(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
pulse_time: float = dataclasses.field(default=1.0)
grace_time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.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 'ADMG'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8e\x07\xe9\xd3') # 0x8e07e9d3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pulse_time))
data.write(b'\xc0R\xbc\x02') # 0xc052bc02
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grace_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage=DamageInfo.from_json(data['damage']),
pulse_time=data['pulse_time'],
grace_time=data['grace_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
'pulse_time': self.pulse_time,
'grace_time': self.grace_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_pulse_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grace_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x337f9524: ('damage', _decode_damage),
0x8e07e9d3: ('pulse_time', _decode_pulse_time),
0xc052bc02: ('grace_time', _decode_grace_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AreaDamage.py | 0.626924 | 0.33704 | AreaDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class StreamedMovie(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
movie_file: str = dataclasses.field(default='')
loop: bool = dataclasses.field(default=False)
video_filter_enabled: bool = dataclasses.field(default=True)
unknown: int = dataclasses.field(default=0)
volume: int = dataclasses.field(default=127)
volume_type: int = dataclasses.field(default=0)
cache_length: float = dataclasses.field(default=0.05000000074505806)
fade_out_time: float = dataclasses.field(default=1.0)
@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 'MOVI'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'X+\x84\xa8') # 0x582b84a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.movie_file.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'6\x96;\xcc') # 0x36963bcc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.video_filter_enabled))
data.write(b'\xa7\x8a\xc0\xc0') # 0xa78ac0c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
data.write(b'\x80\xc6l7') # 0x80c66c37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume))
data.write(b'\xe1\xffO\x04') # 0xe1ff4f04
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume_type))
data.write(b'\xad\x9e\xb7\x7f') # 0xad9eb77f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cache_length))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
movie_file=data['movie_file'],
loop=data['loop'],
video_filter_enabled=data['video_filter_enabled'],
unknown=data['unknown'],
volume=data['volume'],
volume_type=data['volume_type'],
cache_length=data['cache_length'],
fade_out_time=data['fade_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'movie_file': self.movie_file,
'loop': self.loop,
'video_filter_enabled': self.video_filter_enabled,
'unknown': self.unknown,
'volume': self.volume,
'volume_type': self.volume_type,
'cache_length': self.cache_length,
'fade_out_time': self.fade_out_time,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_movie_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_video_filter_enabled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_volume_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_cache_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x582b84a8: ('movie_file', _decode_movie_file),
0xeda47ff6: ('loop', _decode_loop),
0x36963bcc: ('video_filter_enabled', _decode_video_filter_enabled),
0xa78ac0c0: ('unknown', _decode_unknown),
0x80c66c37: ('volume', _decode_volume),
0xe1ff4f04: ('volume_type', _decode_volume_type),
0xad9eb77f: ('cache_length', _decode_cache_length),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/StreamedMovie.py | 0.573201 | 0.365796 | StreamedMovie.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Relay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.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 'SRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Relay.py | 0.640748 | 0.354405 | Relay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.SurroundPan import SurroundPan
from retro_data_structures.properties.corruption.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Sound(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
sound_effect: AssetId = dataclasses.field(metadata={'asset_types': ['CAUD']}, default=default_asset_id)
min_audible_distance: float = dataclasses.field(default=0.0)
max_audible_distance: float = dataclasses.field(default=0.0)
delay_time: float = dataclasses.field(default=0.0)
volume: float = dataclasses.field(default=1.0)
volume_variance: float = dataclasses.field(default=0.0)
surround_pan: SurroundPan = dataclasses.field(default_factory=SurroundPan)
pan_variance: float = dataclasses.field(default=0.0)
pitch: float = dataclasses.field(default=0.0)
ambient: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
can_occlude: bool = dataclasses.field(default=False)
play_always: bool = dataclasses.field(default=False)
sound_is_music: bool = dataclasses.field(default=False)
update_velocity: bool = dataclasses.field(default=False)
ignore_generated_behavior: bool = dataclasses.field(default=False)
sound_is_ui_sound: bool = dataclasses.field(default=False)
sound_is_speech: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.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 'SOND'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x13') # 19 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\x1a1v') # 0x771a3176
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.sound_effect))
data.write(b'%\xd4y\x8a') # 0x25d4798a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_audible_distance))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
data.write(b'\x8e\x16\xe0\x12') # 0x8e16e012
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.delay_time))
data.write(b'\xc7\xa7\xf1\x89') # 0xc7a7f189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume))
data.write(b'\xf0\xe4KV') # 0xf0e44b56
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.volume_variance))
data.write(b'\x0b\xb6&9') # 0xbb62639
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surround_pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95#rX') # 0x95237258
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pan_variance))
data.write(b',\xc5\xcb\x93') # 0x2cc5cb93
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pitch))
data.write(b'\x89q\xb7\xa7') # 0x8971b7a7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ambient))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\x94r\x11c') # 0x94721163
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_occlude))
data.write(b'\r\x7f\x8c\x7f') # 0xd7f8c7f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.play_always))
data.write(b'v\xd4\x00\x91') # 0x76d40091
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_music))
data.write(b'\x90\x14\\\xd2') # 0x90145cd2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.update_velocity))
data.write(b'\xeb\xd1\x92s') # 0xebd19273
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.ignore_generated_behavior))
data.write(b'\x18oe\x92') # 0x186f6592
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_ui_sound))
data.write(b'^\to\xd2') # 0x5e096fd2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.sound_is_speech))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
sound_effect=data['sound_effect'],
min_audible_distance=data['min_audible_distance'],
max_audible_distance=data['max_audible_distance'],
delay_time=data['delay_time'],
volume=data['volume'],
volume_variance=data['volume_variance'],
surround_pan=SurroundPan.from_json(data['surround_pan']),
pan_variance=data['pan_variance'],
pitch=data['pitch'],
ambient=data['ambient'],
auto_start=data['auto_start'],
can_occlude=data['can_occlude'],
play_always=data['play_always'],
sound_is_music=data['sound_is_music'],
update_velocity=data['update_velocity'],
ignore_generated_behavior=data['ignore_generated_behavior'],
sound_is_ui_sound=data['sound_is_ui_sound'],
sound_is_speech=data['sound_is_speech'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'sound_effect': self.sound_effect,
'min_audible_distance': self.min_audible_distance,
'max_audible_distance': self.max_audible_distance,
'delay_time': self.delay_time,
'volume': self.volume,
'volume_variance': self.volume_variance,
'surround_pan': self.surround_pan.to_json(),
'pan_variance': self.pan_variance,
'pitch': self.pitch,
'ambient': self.ambient,
'auto_start': self.auto_start,
'can_occlude': self.can_occlude,
'play_always': self.play_always,
'sound_is_music': self.sound_is_music,
'update_velocity': self.update_velocity,
'ignore_generated_behavior': self.ignore_generated_behavior,
'sound_is_ui_sound': self.sound_is_ui_sound,
'sound_is_speech': self.sound_is_speech,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_sound_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_min_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_audible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_delay_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_volume_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_surround_pan(data: typing.BinaryIO, property_size: int):
return SurroundPan.from_stream(data, property_size)
def _decode_pan_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_occlude(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_play_always(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_music(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_update_velocity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_ignore_generated_behavior(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_ui_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_sound_is_speech(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x771a3176: ('sound_effect', _decode_sound_effect),
0x25d4798a: ('min_audible_distance', _decode_min_audible_distance),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
0x8e16e012: ('delay_time', _decode_delay_time),
0xc7a7f189: ('volume', _decode_volume),
0xf0e44b56: ('volume_variance', _decode_volume_variance),
0xbb62639: ('surround_pan', _decode_surround_pan),
0x95237258: ('pan_variance', _decode_pan_variance),
0x2cc5cb93: ('pitch', _decode_pitch),
0x8971b7a7: ('ambient', _decode_ambient),
0x3217dff8: ('auto_start', _decode_auto_start),
0x94721163: ('can_occlude', _decode_can_occlude),
0xd7f8c7f: ('play_always', _decode_play_always),
0x76d40091: ('sound_is_music', _decode_sound_is_music),
0x90145cd2: ('update_velocity', _decode_update_velocity),
0xebd19273: ('ignore_generated_behavior', _decode_ignore_generated_behavior),
0x186f6592: ('sound_is_ui_sound', _decode_sound_is_ui_sound),
0x5e096fd2: ('sound_is_speech', _decode_sound_is_speech),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Sound.py | 0.586996 | 0.319015 | Sound.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class PositionRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
one_shot: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.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 'SPRL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xd7\xb7\xbb') # 0xead7b7bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.one_shot))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'one_shot': self.one_shot,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_one_shot(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/PositionRelay.py | 0.641198 | 0.352007 | PositionRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
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 AtomicAlpha(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
bomb_weapon: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
bomb_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
bomb_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
bomb_drop_delay: float = dataclasses.field(default=3.0)
bomb_reappear_delay: float = dataclasses.field(default=2.0)
bomb_reappear_time: float = dataclasses.field(default=1.5)
invisible: bool = dataclasses.field(default=False)
home_while_charging: 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 'ATMA'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_AtomicAlpha.rso']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0b') # 11 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~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'\x17 \xb9\x1f') # 0x1720b91f
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bomb_weapon))
data.write(b'\xc7_\x95\x16') # 0xc75f9516
data.write(b'\x00\x08') # size
data.write(struct.pack(">Q", self.bomb_model))
data.write(b'\xb4\x8d_\xe6') # 0xb48d5fe6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.bomb_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\xba\x00\x9c') # 0x66ba009c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_drop_delay))
data.write(b'y\xddf\xa9') # 0x79dd66a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_reappear_delay))
data.write(b'\xbbB\x84\xea') # 0xbb4284ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bomb_reappear_time))
data.write(b'p\x17\xed\xfc') # 0x7017edfc
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.invisible))
data.write(b'&9\xf0\xb9') # 0x2639f0b9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.home_while_charging))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
bomb_weapon=data['bomb_weapon'],
bomb_model=data['bomb_model'],
bomb_damage=DamageInfo.from_json(data['bomb_damage']),
bomb_drop_delay=data['bomb_drop_delay'],
bomb_reappear_delay=data['bomb_reappear_delay'],
bomb_reappear_time=data['bomb_reappear_time'],
invisible=data['invisible'],
home_while_charging=data['home_while_charging'],
)
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(),
'bomb_weapon': self.bomb_weapon,
'bomb_model': self.bomb_model,
'bomb_damage': self.bomb_damage.to_json(),
'bomb_drop_delay': self.bomb_drop_delay,
'bomb_reappear_delay': self.bomb_reappear_delay,
'bomb_reappear_time': self.bomb_reappear_time,
'invisible': self.invisible,
'home_while_charging': self.home_while_charging,
}
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_bomb_weapon(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bomb_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">Q", data.read(8))[0]
def _decode_bomb_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_bomb_drop_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bomb_reappear_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_bomb_reappear_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_invisible(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_home_while_charging(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),
0x7e397fed: ('actor_information', _decode_actor_information),
0xb3774750: ('patterned', _decode_patterned),
0x1720b91f: ('bomb_weapon', _decode_bomb_weapon),
0xc75f9516: ('bomb_model', _decode_bomb_model),
0xb48d5fe6: ('bomb_damage', _decode_bomb_damage),
0x66ba009c: ('bomb_drop_delay', _decode_bomb_drop_delay),
0x79dd66a9: ('bomb_reappear_delay', _decode_bomb_reappear_delay),
0xbb4284ea: ('bomb_reappear_time', _decode_bomb_reappear_time),
0x7017edfc: ('invisible', _decode_invisible),
0x2639f0b9: ('home_while_charging', _decode_home_while_charging),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AtomicAlpha.py | 0.601125 | 0.306268 | AtomicAlpha.py | 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.CameraOrientation import CameraOrientation
from retro_data_structures.properties.corruption.archetypes.CinematicBlend import CinematicBlend
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.SavedStateID import SavedStateID
from retro_data_structures.properties.corruption.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.corruption.core.Spline import Spline
@dataclasses.dataclass()
class CinematicCamera(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
object_id: SavedStateID = dataclasses.field(default_factory=SavedStateID)
camera_mode: enums.CameraMode = dataclasses.field(default=enums.CameraMode.Unknown1)
use_script_object_transform: bool = dataclasses.field(default=False)
animation: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
cinematic_start_type: enums.CinematicStartType = dataclasses.field(default=enums.CinematicStartType.Unknown1)
blend: CinematicBlend = dataclasses.field(default_factory=CinematicBlend)
cinematic_ends_type: enums.CinematicEndsType = dataclasses.field(default=enums.CinematicEndsType.Unknown1)
end_time: float = dataclasses.field(default=10.0)
unknown: int = dataclasses.field(default=2132) # Flagset
motion_control_spline: Spline = dataclasses.field(default_factory=Spline)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
orientation_behavior: CameraOrientation = dataclasses.field(default_factory=CameraOrientation)
fov_spline: Spline = dataclasses.field(default_factory=Spline)
roll_spline: Spline = dataclasses.field(default_factory=Spline)
slowmo_control_spline: Spline = dataclasses.field(default_factory=Spline)
near_plane_distance_spline: Spline = dataclasses.field(default_factory=Spline)
far_plane_distance_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.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 'CINE'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x12') # 18 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x16\xd9\xa7]') # 0x16d9a75d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.object_id.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcc\x08\xef\x1b') # 0xcc08ef1b
data.write(b'\x00\x04') # size
self.camera_mode.to_stream(data)
data.write(b'c\x87\xe4K') # 0x6387e44b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_script_object_transform))
data.write(b'\xa3\xd6?D') # 0xa3d63f44
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb1\xac\x91v') # 0xb1ac9176
data.write(b'\x00\x04') # size
self.cinematic_start_type.to_stream(data)
data.write(b'\x9e\xc6Rs') # 0x9ec65273
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'\x97J\x96\x1f') # 0x974a961f
data.write(b'\x00\x04') # size
self.cinematic_ends_type.to_stream(data)
data.write(b'\xab\x81Q\xea') # 0xab8151ea
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.end_time))
data.write(b'\x05\xc5\xfcn') # 0x5c5fc6e
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown))
data.write(b"'\xe5\xf8t") # 0x27e5f874
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xdf\xbf\xa7') # 0xc4dfbfa7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'e\xfc\x11\xff') # 0x65fc11ff
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orientation_behavior.to_stream(data, default_override={'orientation_type': 648890987, 'flags_orientation': 12})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'hh\xd4\xb3') # 0x6868d4b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.fov_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'nm\x8e\xfd') # 0x6e6d8efd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.roll_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf4\xf4y\x8e') # 0xf4f4798e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.slowmo_control_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b')QX\x02') # 0x29515802
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.near_plane_distance_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\x18e\xa6') # 0xdf1865a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.far_plane_distance_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
object_id=SavedStateID.from_json(data['object_id']),
camera_mode=enums.CameraMode.from_json(data['camera_mode']),
use_script_object_transform=data['use_script_object_transform'],
animation=AnimationParameters.from_json(data['animation']),
cinematic_start_type=enums.CinematicStartType.from_json(data['cinematic_start_type']),
blend=CinematicBlend.from_json(data['blend']),
cinematic_ends_type=enums.CinematicEndsType.from_json(data['cinematic_ends_type']),
end_time=data['end_time'],
unknown=data['unknown'],
motion_control_spline=Spline.from_json(data['motion_control_spline']),
target_control_spline=Spline.from_json(data['target_control_spline']),
orientation_behavior=CameraOrientation.from_json(data['orientation_behavior']),
fov_spline=Spline.from_json(data['fov_spline']),
roll_spline=Spline.from_json(data['roll_spline']),
slowmo_control_spline=Spline.from_json(data['slowmo_control_spline']),
near_plane_distance_spline=Spline.from_json(data['near_plane_distance_spline']),
far_plane_distance_spline=Spline.from_json(data['far_plane_distance_spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'object_id': self.object_id.to_json(),
'camera_mode': self.camera_mode.to_json(),
'use_script_object_transform': self.use_script_object_transform,
'animation': self.animation.to_json(),
'cinematic_start_type': self.cinematic_start_type.to_json(),
'blend': self.blend.to_json(),
'cinematic_ends_type': self.cinematic_ends_type.to_json(),
'end_time': self.end_time,
'unknown': self.unknown,
'motion_control_spline': self.motion_control_spline.to_json(),
'target_control_spline': self.target_control_spline.to_json(),
'orientation_behavior': self.orientation_behavior.to_json(),
'fov_spline': self.fov_spline.to_json(),
'roll_spline': self.roll_spline.to_json(),
'slowmo_control_spline': self.slowmo_control_spline.to_json(),
'near_plane_distance_spline': self.near_plane_distance_spline.to_json(),
'far_plane_distance_spline': self.far_plane_distance_spline.to_json(),
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_object_id(data: typing.BinaryIO, property_size: int):
return SavedStateID.from_stream(data, property_size)
def _decode_camera_mode(data: typing.BinaryIO, property_size: int):
return enums.CameraMode.from_stream(data)
def _decode_use_script_object_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_animation(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_cinematic_start_type(data: typing.BinaryIO, property_size: int):
return enums.CinematicStartType.from_stream(data)
def _decode_blend(data: typing.BinaryIO, property_size: int):
return CinematicBlend.from_stream(data, property_size)
def _decode_cinematic_ends_type(data: typing.BinaryIO, property_size: int):
return enums.CinematicEndsType.from_stream(data)
def _decode_end_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_motion_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_orientation_behavior(data: typing.BinaryIO, property_size: int):
return CameraOrientation.from_stream(data, property_size, default_override={'orientation_type': 648890987, 'flags_orientation': 12})
def _decode_fov_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_roll_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_slowmo_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_near_plane_distance_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_far_plane_distance_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x16d9a75d: ('object_id', _decode_object_id),
0xcc08ef1b: ('camera_mode', _decode_camera_mode),
0x6387e44b: ('use_script_object_transform', _decode_use_script_object_transform),
0xa3d63f44: ('animation', _decode_animation),
0xb1ac9176: ('cinematic_start_type', _decode_cinematic_start_type),
0x9ec65273: ('blend', _decode_blend),
0x974a961f: ('cinematic_ends_type', _decode_cinematic_ends_type),
0xab8151ea: ('end_time', _decode_end_time),
0x5c5fc6e: ('unknown', _decode_unknown),
0x27e5f874: ('motion_control_spline', _decode_motion_control_spline),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0x65fc11ff: ('orientation_behavior', _decode_orientation_behavior),
0x6868d4b3: ('fov_spline', _decode_fov_spline),
0x6e6d8efd: ('roll_spline', _decode_roll_spline),
0xf4f4798e: ('slowmo_control_spline', _decode_slowmo_control_spline),
0x29515802: ('near_plane_distance_spline', _decode_near_plane_distance_spline),
0xdf1865a6: ('far_plane_distance_spline', _decode_far_plane_distance_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/CinematicCamera.py | 0.554832 | 0.242789 | CinematicCamera.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.corruption.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.corruption.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.corruption.archetypes.PTCNoseTurretData import PTCNoseTurretData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class NoseTurret(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
ptc_nose_turret_data: PTCNoseTurretData = dataclasses.field(default_factory=PTCNoseTurretData)
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 'NOTU'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_NoseTurret.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'>]\xd2\x08') # 0x3e5dd208
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ptc_nose_turret_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={'step_up_height': 1.0, 'detection_range': 50.0, 'min_attack_range': 5.0, 'max_attack_range': 25.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']),
ptc_nose_turret_data=PTCNoseTurretData.from_json(data['ptc_nose_turret_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(),
'ptc_nose_turret_data': self.ptc_nose_turret_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_ptc_nose_turret_data(data: typing.BinaryIO, property_size: int):
return PTCNoseTurretData.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, 'detection_range': 50.0, 'min_attack_range': 5.0, 'max_attack_range': 25.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),
0x3e5dd208: ('ptc_nose_turret_data', _decode_ptc_nose_turret_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/NoseTurret.py | 0.607314 | 0.293227 | NoseTurret.py | 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.GragnolFlyerData import GragnolFlyerData
from retro_data_structures.properties.corruption.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class GragnolFlyer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
gragnol_flyer_properties: GragnolFlyerData = dataclasses.field(default_factory=GragnolFlyerData)
@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 'GRFL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_GragnolFlyer.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={'creature_size': 1})
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'G\xed2\xf2') # 0x47ed32f2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.gragnol_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']),
gragnol_flyer_properties=GragnolFlyerData.from_json(data['gragnol_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(),
'gragnol_flyer_properties': self.gragnol_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, default_override={'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_gragnol_flyer_properties(data: typing.BinaryIO, property_size: int):
return GragnolFlyerData.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),
0x47ed32f2: ('gragnol_flyer_properties', _decode_gragnol_flyer_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GragnolFlyer.py | 0.606615 | 0.321686 | GragnolFlyer.py | 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.SteamLordData import SteamLordData
@dataclasses.dataclass()
class SteamLord(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
steam_lord_data: SteamLordData = dataclasses.field(default_factory=SteamLordData)
@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 'STML'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SteamLord.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'\x01\xd5\x82<') # 0x1d5823c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.steam_lord_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']),
steam_lord_data=SteamLordData.from_json(data['steam_lord_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(),
'steam_lord_data': self.steam_lord_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_steam_lord_data(data: typing.BinaryIO, property_size: int):
return SteamLordData.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),
0x1d5823c: ('steam_lord_data', _decode_steam_lord_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SteamLord.py | 0.546012 | 0.35031 | SteamLord.py | 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 AlarmController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
stage1_timer: 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 'ALRM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xde\x80\x88\xc9') # 0xde8088c9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stage1_timer))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
stage1_timer=data['stage1_timer'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'stage1_timer': self.stage1_timer,
}
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_stage1_timer(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),
0xde8088c9: ('stage1_timer', _decode_stage1_timer),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AlarmController.py | 0.608478 | 0.343149 | AlarmController.py | 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.UnknownStruct43 import UnknownStruct43
from retro_data_structures.properties.corruption.archetypes.WallCrawlerData import WallCrawlerData
@dataclasses.dataclass()
class GellSac(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_struct43: UnknownStruct43 = dataclasses.field(default_factory=UnknownStruct43)
@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 'GSAC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_GellSac.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})
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"'f\xcd\x96") # 0x2766cd96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct43.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_struct43=UnknownStruct43.from_json(data['unknown_struct43']),
)
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_struct43': self.unknown_struct43.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})
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_struct43(data: typing.BinaryIO, property_size: int):
return UnknownStruct43.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),
0x2766cd96: ('unknown_struct43', _decode_unknown_struct43),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/GellSac.py | 0.651133 | 0.314235 | GellSac.py | 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 Repulsor(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shape: int = dataclasses.field(default=0)
radius: float = dataclasses.field(default=1.0)
value: float = dataclasses.field(default=-1.0)
flags_repulsor: 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 'REPL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xf9\xbb-\xb6') # 0xf9bb2db6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.shape))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\x8d\xcd\x89x') # 0x8dcd8978
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value))
data.write(b'\x8a\xefk\xd2') # 0x8aef6bd2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_repulsor))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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'],
radius=data['radius'],
value=data['value'],
flags_repulsor=data['flags_repulsor'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shape': self.shape,
'radius': self.radius,
'value': self.value,
'flags_repulsor': self.flags_repulsor,
}
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_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_flags_repulsor(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),
0xf9bb2db6: ('shape', _decode_shape),
0x78c507eb: ('radius', _decode_radius),
0x8dcd8978: ('value', _decode_value),
0x8aef6bd2: ('flags_repulsor', _decode_flags_repulsor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/Repulsor.py | 0.623377 | 0.357792 | Repulsor.py | 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.SwarmBotData import SwarmBotData
@dataclasses.dataclass()
class SwarmBot(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
swarm_bot_properties: SwarmBotData = dataclasses.field(default_factory=SwarmBotData)
@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 'SWBT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_SwarmBot.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'?\xa5\xc1[') # 0x3fa5c15b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swarm_bot_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']),
swarm_bot_properties=SwarmBotData.from_json(data['swarm_bot_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(),
'swarm_bot_properties': self.swarm_bot_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_swarm_bot_properties(data: typing.BinaryIO, property_size: int):
return SwarmBotData.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),
0x3fa5c15b: ('swarm_bot_properties', _decode_swarm_bot_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/SwarmBot.py | 0.59843 | 0.320223 | SwarmBot.py | 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.UnknownStruct1 import UnknownStruct1
@dataclasses.dataclass()
class AIFuse(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_struct1: UnknownStruct1 = dataclasses.field(default_factory=UnknownStruct1)
@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 'AIFZ'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RSO_ScriptAIFuse.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'%\xe1\xe3\xb6') # 0x25e1e3b6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct1.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']),
unknown_struct1=UnknownStruct1.from_json(data['unknown_struct1']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'unknown_struct1': self.unknown_struct1.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_unknown_struct1(data: typing.BinaryIO, property_size: int):
return UnknownStruct1.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0x25e1e3b6: ('unknown_struct1', _decode_unknown_struct1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/corruption/objects/AIFuse.py | 0.675336 | 0.313512 | AIFuse.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class ColorMP1(BaseProperty):
r: float = dataclasses.field(default=0.0)
g: float = dataclasses.field(default=0.0)
b: float = dataclasses.field(default=0.0)
a: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\x04\x00') # 4 properties
data.write(b'\xd1\x89\x08\x11') # 0x110889d1
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.r))
data.write(b'"\xffz\x8a') # 0x8a7aff22
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.g))
data.write(b'\xe9IS*') # 0x2a5349e9
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.b))
data.write(b':\xc9d\xe3') # 0xe364c93a
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.a))
@classmethod
def from_json(cls, data: dict):
return cls(
r=data['r'],
g=data['g'],
b=data['b'],
a=data['a'],
)
def to_json(self) -> dict:
return {
'r': self.r,
'g': self.g,
'b': self.b,
'a': self.a,
}
_FAST_FORMAT = None
_FAST_IDS = (0x110889d1, 0x8a7aff22, 0x2a5349e9, 0xe364c93a)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ColorMP1]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<LHfLHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(40))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return ColorMP1(
dec[2],
dec[5],
dec[8],
dec[11],
)
def _decode_r(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_g(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_b(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_a(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]]] = {
0x110889d1: ('r', _decode_r),
0x8a7aff22: ('g', _decode_g),
0x2a5349e9: ('b', _decode_b),
0xe364c93a: ('a', _decode_a),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/ColorMP1.py | 0.652463 | 0.31875 | ColorMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import retro_data_structures.enums.prime_remastered as enums
@dataclasses.dataclass()
class VisorMP1(BaseProperty):
unknown_1: bool = dataclasses.field(default=False)
unknown_2: bool = dataclasses.field(default=False)
unknown_3: bool = dataclasses.field(default=False)
visor_flags: enums.VisorFlags = dataclasses.field(default=enums.VisorFlags(0))
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x00') # 0 properties
num_properties_written = 0
if self.unknown_1 != default_override.get('unknown_1', False):
num_properties_written += 1
data.write(b'\x15P\xf7\x82') # 0x82f75015
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unknown_1))
if self.unknown_2 != default_override.get('unknown_2', False):
num_properties_written += 1
data.write(b'\x12\xfcIQ') # 0x5149fc12
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unknown_2))
if self.unknown_3 != default_override.get('unknown_3', False):
num_properties_written += 1
data.write(b'P\xca\x82\x13') # 0x1382ca50
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unknown_3))
if self.visor_flags != default_override.get('visor_flags', enums.VisorFlags(0)):
num_properties_written += 1
data.write(b'\xa5V\x8aR') # 0x528a56a5
data.write(b'\x04\x00') # size
self.visor_flags.to_stream(data)
if num_properties_written != 0:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_1=data['unknown_1'],
unknown_2=data['unknown_2'],
unknown_3=data['unknown_3'],
visor_flags=enums.VisorFlags.from_json(data['visor_flags']),
)
def to_json(self) -> dict:
return {
'unknown_1': self.unknown_1,
'unknown_2': self.unknown_2,
'unknown_3': self.unknown_3,
'visor_flags': self.visor_flags.to_json(),
}
_FAST_FORMAT = None
_FAST_IDS = (0x82f75015, 0x5149fc12, 0x1382ca50, 0x528a56a5)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VisorMP1]:
if property_count != 4:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<LH?LH?LH?LHL')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(31))
if (dec[0], dec[3], dec[6], dec[9]) != _FAST_IDS:
data.seek(before)
return None
return VisorMP1(
dec[2],
dec[5],
dec[8],
enums.VisorFlags(dec[11]),
)
def _decode_unknown_1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unknown_2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unknown_3(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_visor_flags(data: typing.BinaryIO, property_size: int):
return enums.VisorFlags.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x82f75015: ('unknown_1', _decode_unknown_1),
0x5149fc12: ('unknown_2', _decode_unknown_2),
0x1382ca50: ('unknown_3', _decode_unknown_3),
0x528a56a5: ('visor_flags', _decode_visor_flags),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/VisorMP1.py | 0.602179 | 0.273559 | VisorMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime_remastered.core.AssetId import AssetId, default_asset_id
import uuid
@dataclasses.dataclass()
class MapInfoMP1(BaseProperty):
unk_int_1: int = dataclasses.field(default=0)
unk_int_2: int = dataclasses.field(default=0)
unk_guid: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x00') # 0 properties
num_properties_written = 0
if self.unk_int_1 != default_override.get('unk_int_1', 0):
num_properties_written += 1
data.write(b'KG\xf8p') # 0x70f8474b
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.unk_int_1))
if self.unk_int_2 != default_override.get('unk_int_2', 0):
num_properties_written += 1
data.write(b'\x12\x8d\xaf\x9c') # 0x9caf8d12
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.unk_int_2))
if self.unk_guid != default_override.get('unk_guid', default_asset_id):
num_properties_written += 1
data.write(b'!2\xa5\x91') # 0x91a53221
data.write(b'\x10\x00') # size
data.write(self.unk_guid.bytes_le)
if num_properties_written != 0:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
unk_int_1=data['unk_int_1'],
unk_int_2=data['unk_int_2'],
unk_guid=uuid.UUID(data['unk_guid']),
)
def to_json(self) -> dict:
return {
'unk_int_1': self.unk_int_1,
'unk_int_2': self.unk_int_2,
'unk_guid': str(self.unk_guid),
}
def _decode_unk_int_1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_unk_int_2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_unk_guid(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x70f8474b: ('unk_int_1', _decode_unk_int_1),
0x9caf8d12: ('unk_int_2', _decode_unk_int_2),
0x91a53221: ('unk_guid', _decode_unk_guid),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/MapInfoMP1.py | 0.518302 | 0.258402 | MapInfoMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime_remastered.core.AssetId import AssetId, default_asset_id
import uuid
@dataclasses.dataclass()
class ScannableMP1(BaseProperty):
scan_file: AssetId = dataclasses.field(metadata={'asset_types': ['SCAN']}, default=default_asset_id)
unk_bool: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x01\x00') # 1 properties
num_properties_written = 1
data.write(b'\xb4\xe2s\x1a') # 0x1a73e2b4
data.write(b'\x10\x00') # size
data.write(self.scan_file.bytes_le)
if self.unk_bool != default_override.get('unk_bool', False):
num_properties_written += 1
data.write(b'9@&\x05') # 0x5264039
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool))
if num_properties_written != 1:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
scan_file=uuid.UUID(data['scan_file']),
unk_bool=data['unk_bool'],
)
def to_json(self) -> dict:
return {
'scan_file': str(self.scan_file),
'unk_bool': self.unk_bool,
}
def _decode_scan_file(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_bool(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]]] = {
0x1a73e2b4: ('scan_file', _decode_scan_file),
0x5264039: ('unk_bool', _decode_unk_bool),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/ScannableMP1.py | 0.556882 | 0.270953 | ScannableMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
@dataclasses.dataclass()
class VectorMP1(BaseProperty):
x: float = dataclasses.field(default=0.0)
y: float = dataclasses.field(default=0.0)
z: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x00') # 0 properties
num_properties_written = 0
if self.x != default_override.get('x', 0.0):
num_properties_written += 1
data.write(b'Q\xe5I&') # 0x2649e551
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.x))
if self.y != default_override.get('y', 0.0):
num_properties_written += 1
data.write(b'\xc6[\xbb\xd2') # 0xd2bb5bc6
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.y))
if self.z != default_override.get('z', 0.0):
num_properties_written += 1
data.write(b'\xb2\x99\x94\x7f') # 0x7f9499b2
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.z))
if num_properties_written != 0:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
x=data['x'],
y=data['y'],
z=data['z'],
)
def to_json(self) -> dict:
return {
'x': self.x,
'y': self.y,
'z': self.z,
}
_FAST_FORMAT = None
_FAST_IDS = (0x2649e551, 0xd2bb5bc6, 0x7f9499b2)
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[VectorMP1]:
if property_count != 3:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<LHfLHfLHf')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(30))
if (dec[0], dec[3], dec[6]) != _FAST_IDS:
data.seek(before)
return None
return VectorMP1(
dec[2],
dec[5],
dec[8],
)
def _decode_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_z(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]]] = {
0x2649e551: ('x', _decode_x),
0xd2bb5bc6: ('y', _decode_y),
0x7f9499b2: ('z', _decode_z),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/VectorMP1.py | 0.631935 | 0.335052 | VectorMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime_remastered.archetypes.LightingMP1 import LightingMP1
from retro_data_structures.properties.prime_remastered.archetypes.ScannableMP1 import ScannableMP1
from retro_data_structures.properties.prime_remastered.archetypes.VisorMP1 import VisorMP1
from retro_data_structures.properties.prime_remastered.core.AssetId import AssetId, default_asset_id
import uuid
@dataclasses.dataclass()
class ActorInformationMP1(BaseProperty):
unk_guid_1: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unk_guid_2: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unk_guid_3: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unk_guid_4: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unk_guid_5: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
unk_float_1: float = dataclasses.field(default=1.0)
unk_bool_4: bool = dataclasses.field(default=False)
lighting: LightingMP1 = dataclasses.field(default_factory=LightingMP1)
scannable: ScannableMP1 = dataclasses.field(default_factory=ScannableMP1)
visor: VisorMP1 = dataclasses.field(default_factory=VisorMP1)
unk_float_2: float = dataclasses.field(default=1.0)
unk_float_3: float = dataclasses.field(default=1.0)
unk_float_4: float = dataclasses.field(default=1.0)
unk_int: int = dataclasses.field(default=0)
water_sort_type: int = dataclasses.field(default=0)
unk_bool_1: bool = dataclasses.field(default=True)
unk_bool_2: bool = dataclasses.field(default=True)
unk_bool_3: bool = dataclasses.field(default=False)
unk_bool_5: bool = dataclasses.field(default=False)
unk_bool_6: bool = dataclasses.field(default=False)
unk_bool_7: bool = dataclasses.field(default=True)
unk_bool_8: bool = dataclasses.field(default=False)
unk_bool_9: bool = dataclasses.field(default=False)
unk_bool_10: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x03\x00') # 3 properties
num_properties_written = 3
if self.unk_guid_1 != default_override.get('unk_guid_1', default_asset_id):
num_properties_written += 1
data.write(b'x\xd76\x00') # 0x36d778
data.write(b'\x10\x00') # size
data.write(self.unk_guid_1.bytes_le)
if self.unk_guid_2 != default_override.get('unk_guid_2', default_asset_id):
num_properties_written += 1
data.write(b'\xa7\xf7h\xab') # 0xab68f7a7
data.write(b'\x10\x00') # size
data.write(self.unk_guid_2.bytes_le)
if self.unk_guid_3 != default_override.get('unk_guid_3', default_asset_id):
num_properties_written += 1
data.write(b':\x05*\x80') # 0x802a053a
data.write(b'\x10\x00') # size
data.write(self.unk_guid_3.bytes_le)
if self.unk_guid_4 != default_override.get('unk_guid_4', default_asset_id):
num_properties_written += 1
data.write(b'7/\x82t') # 0x74822f37
data.write(b'\x10\x00') # size
data.write(self.unk_guid_4.bytes_le)
if self.unk_guid_5 != default_override.get('unk_guid_5', default_asset_id):
num_properties_written += 1
data.write(b'z\xa9d\x03') # 0x364a97a
data.write(b'\x10\x00') # size
data.write(self.unk_guid_5.bytes_le)
if self.unk_float_1 != default_override.get('unk_float_1', 1.0):
num_properties_written += 1
data.write(b'8\xa7\xa56') # 0x36a5a738
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float_1))
if self.unk_bool_4 != default_override.get('unk_bool_4', False):
num_properties_written += 1
data.write(b'\xa7\xccQb') # 0x6251cca7
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_4))
data.write(b'\xf2<\x9e\x14') # 0x149e3cf2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.lighting.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'<\x08\r\xe5') # 0xe50d083c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scannable.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
data.write(b'x\x0bQ\xaf') # 0xaf510b78
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)
if self.unk_float_2 != default_override.get('unk_float_2', 1.0):
num_properties_written += 1
data.write(b'U]\x07\x90') # 0x90075d55
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float_2))
if self.unk_float_3 != default_override.get('unk_float_3', 1.0):
num_properties_written += 1
data.write(b'\xfd\x9fu\x1a') # 0x1a759ffd
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float_3))
if self.unk_float_4 != default_override.get('unk_float_4', 1.0):
num_properties_written += 1
data.write(b'\xdd5Q\xde') # 0xde5135dd
data.write(b'\x04\x00') # size
data.write(struct.pack('<f', self.unk_float_4))
if self.unk_int != default_override.get('unk_int', 0):
num_properties_written += 1
data.write(b'\xe8\xb4\x89\xba') # 0xba89b4e8
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.unk_int))
if self.water_sort_type != default_override.get('water_sort_type', 0):
num_properties_written += 1
data.write(b'jU"\xb2') # 0xb222556a
data.write(b'\x04\x00') # size
data.write(struct.pack('<l', self.water_sort_type))
if self.unk_bool_1 != default_override.get('unk_bool_1', True):
num_properties_written += 1
data.write(b'\x18\x08A\x8a') # 0x8a410818
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_1))
if self.unk_bool_2 != default_override.get('unk_bool_2', True):
num_properties_written += 1
data.write(b'\x1bm\x06w') # 0x77066d1b
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_2))
if self.unk_bool_3 != default_override.get('unk_bool_3', False):
num_properties_written += 1
data.write(b'\xe2^@~') # 0x7e405ee2
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_3))
if self.unk_bool_5 != default_override.get('unk_bool_5', False):
num_properties_written += 1
data.write(b'\xfbQ\x07\x05') # 0x50751fb
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_5))
if self.unk_bool_6 != default_override.get('unk_bool_6', False):
num_properties_written += 1
data.write(b'\xc9]\xba\xc8') # 0xc8ba5dc9
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_6))
if self.unk_bool_7 != default_override.get('unk_bool_7', True):
num_properties_written += 1
data.write(b',:\xb2\xc7') # 0xc7b23a2c
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_7))
if self.unk_bool_8 != default_override.get('unk_bool_8', False):
num_properties_written += 1
data.write(b'\xfaN\xcaJ') # 0x4aca4efa
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_8))
if self.unk_bool_9 != default_override.get('unk_bool_9', False):
num_properties_written += 1
data.write(b']\x95\xd8j') # 0x6ad8955d
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_9))
if self.unk_bool_10 != default_override.get('unk_bool_10', True):
num_properties_written += 1
data.write(b'c\x99\xb3a') # 0x61b39963
data.write(b'\x01\x00') # size
data.write(struct.pack('<?', self.unk_bool_10))
if num_properties_written != 3:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
unk_guid_1=uuid.UUID(data['unk_guid_1']),
unk_guid_2=uuid.UUID(data['unk_guid_2']),
unk_guid_3=uuid.UUID(data['unk_guid_3']),
unk_guid_4=uuid.UUID(data['unk_guid_4']),
unk_guid_5=uuid.UUID(data['unk_guid_5']),
unk_float_1=data['unk_float_1'],
unk_bool_4=data['unk_bool_4'],
lighting=LightingMP1.from_json(data['lighting']),
scannable=ScannableMP1.from_json(data['scannable']),
visor=VisorMP1.from_json(data['visor']),
unk_float_2=data['unk_float_2'],
unk_float_3=data['unk_float_3'],
unk_float_4=data['unk_float_4'],
unk_int=data['unk_int'],
water_sort_type=data['water_sort_type'],
unk_bool_1=data['unk_bool_1'],
unk_bool_2=data['unk_bool_2'],
unk_bool_3=data['unk_bool_3'],
unk_bool_5=data['unk_bool_5'],
unk_bool_6=data['unk_bool_6'],
unk_bool_7=data['unk_bool_7'],
unk_bool_8=data['unk_bool_8'],
unk_bool_9=data['unk_bool_9'],
unk_bool_10=data['unk_bool_10'],
)
def to_json(self) -> dict:
return {
'unk_guid_1': str(self.unk_guid_1),
'unk_guid_2': str(self.unk_guid_2),
'unk_guid_3': str(self.unk_guid_3),
'unk_guid_4': str(self.unk_guid_4),
'unk_guid_5': str(self.unk_guid_5),
'unk_float_1': self.unk_float_1,
'unk_bool_4': self.unk_bool_4,
'lighting': self.lighting.to_json(),
'scannable': self.scannable.to_json(),
'visor': self.visor.to_json(),
'unk_float_2': self.unk_float_2,
'unk_float_3': self.unk_float_3,
'unk_float_4': self.unk_float_4,
'unk_int': self.unk_int,
'water_sort_type': self.water_sort_type,
'unk_bool_1': self.unk_bool_1,
'unk_bool_2': self.unk_bool_2,
'unk_bool_3': self.unk_bool_3,
'unk_bool_5': self.unk_bool_5,
'unk_bool_6': self.unk_bool_6,
'unk_bool_7': self.unk_bool_7,
'unk_bool_8': self.unk_bool_8,
'unk_bool_9': self.unk_bool_9,
'unk_bool_10': self.unk_bool_10,
}
def _decode_unk_guid_1(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_guid_2(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_guid_3(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_guid_4(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_guid_5(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_unk_float_1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_unk_bool_4(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_lighting(data: typing.BinaryIO, property_size: int):
return LightingMP1.from_stream(data, property_size)
def _decode_scannable(data: typing.BinaryIO, property_size: int):
return ScannableMP1.from_stream(data, property_size)
def _decode_visor(data: typing.BinaryIO, property_size: int):
return VisorMP1.from_stream(data, property_size)
def _decode_unk_float_2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_unk_float_3(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_unk_float_4(data: typing.BinaryIO, property_size: int):
return struct.unpack('<f', data.read(4))[0]
def _decode_unk_int(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_water_sort_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('<l', data.read(4))[0]
def _decode_unk_bool_1(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_2(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_3(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_5(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_6(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_7(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_8(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_9(data: typing.BinaryIO, property_size: int):
return struct.unpack('<?', data.read(1))[0]
def _decode_unk_bool_10(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]]] = {
0x36d778: ('unk_guid_1', _decode_unk_guid_1),
0xab68f7a7: ('unk_guid_2', _decode_unk_guid_2),
0x802a053a: ('unk_guid_3', _decode_unk_guid_3),
0x74822f37: ('unk_guid_4', _decode_unk_guid_4),
0x364a97a: ('unk_guid_5', _decode_unk_guid_5),
0x36a5a738: ('unk_float_1', _decode_unk_float_1),
0x6251cca7: ('unk_bool_4', _decode_unk_bool_4),
0x149e3cf2: ('lighting', _decode_lighting),
0xe50d083c: ('scannable', _decode_scannable),
0xaf510b78: ('visor', _decode_visor),
0x90075d55: ('unk_float_2', _decode_unk_float_2),
0x1a759ffd: ('unk_float_3', _decode_unk_float_3),
0xde5135dd: ('unk_float_4', _decode_unk_float_4),
0xba89b4e8: ('unk_int', _decode_unk_int),
0xb222556a: ('water_sort_type', _decode_water_sort_type),
0x8a410818: ('unk_bool_1', _decode_unk_bool_1),
0x77066d1b: ('unk_bool_2', _decode_unk_bool_2),
0x7e405ee2: ('unk_bool_3', _decode_unk_bool_3),
0x50751fb: ('unk_bool_5', _decode_unk_bool_5),
0xc8ba5dc9: ('unk_bool_6', _decode_unk_bool_6),
0xc7b23a2c: ('unk_bool_7', _decode_unk_bool_7),
0x4aca4efa: ('unk_bool_8', _decode_unk_bool_8),
0x6ad8955d: ('unk_bool_9', _decode_unk_bool_9),
0x61b39963: ('unk_bool_10', _decode_unk_bool_10),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/ActorInformationMP1.py | 0.525612 | 0.239561 | ActorInformationMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class LightingMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[LightingMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return LightingMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/LightingMP1.py | 0.608361 | 0.263291 | LightingMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
from retro_data_structures.properties.prime_remastered.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.prime_remastered.core.PooledString import PooledString
import uuid
@dataclasses.dataclass()
class AnimSetMP1(BaseProperty):
id: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
str1: PooledString = dataclasses.field(default_factory=PooledString)
str2: PooledString = dataclasses.field(default_factory=PooledString)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
num_properties_offset = data.tell()
data.write(b'\x00\x00') # 0 properties
num_properties_written = 0
if self.id != default_override.get('id', default_asset_id):
num_properties_written += 1
data.write(b'\x85\xd8\x89\xa5') # 0xa589d885
data.write(b'\x10\x00') # size
data.write(self.id.bytes_le)
if self.str1 != default_override.get('str1', PooledString()):
num_properties_written += 1
data.write(b'\xf0\xc0\xf0\xd6') # 0xd6f0c0f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.str1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if self.str2 != default_override.get('str2', PooledString()):
num_properties_written += 1
data.write(b'\x01:\xc0\x87') # 0x87c03a01
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.str2.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack("<H", after - before - 2))
data.seek(after)
if num_properties_written != 0:
struct_end_offset = data.tell()
data.seek(num_properties_offset)
data.write(struct.pack("<H", num_properties_written))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
id=uuid.UUID(data['id']),
str1=PooledString.from_json(data['str1']),
str2=PooledString.from_json(data['str2']),
)
def to_json(self) -> dict:
return {
'id': str(self.id),
'str1': self.str1.to_json(),
'str2': self.str2.to_json(),
}
def _decode_id(data: typing.BinaryIO, property_size: int):
return uuid.UUID(bytes_le=data.read(16))
def _decode_str1(data: typing.BinaryIO, property_size: int):
return PooledString.from_stream(data, property_size)
def _decode_str2(data: typing.BinaryIO, property_size: int):
return PooledString.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0xa589d885: ('id', _decode_id),
0xd6f0c0f0: ('str1', _decode_str1),
0x87c03a01: ('str2', _decode_str2),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/archetypes/AnimSetMP1.py | 0.551091 | 0.241512 | AnimSetMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class WaterTransitionMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[WaterTransitionMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return WaterTransitionMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/WaterTransitionMP1.py | 0.615435 | 0.257964 | WaterTransitionMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PathGenerator(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PathGenerator]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PathGenerator(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PathGenerator.py | 0.614047 | 0.267223 | PathGenerator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class DynamicActorCollision(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[DynamicActorCollision]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return DynamicActorCollision(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/DynamicActorCollision.py | 0.631253 | 0.255971 | DynamicActorCollision.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ToneSelectorHint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ToneSelectorHint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ToneSelectorHint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ToneSelectorHint.py | 0.603581 | 0.249482 | ToneSelectorHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CameraPredictivePitchHint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CameraPredictivePitchHint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CameraPredictivePitchHint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CameraPredictivePitchHint.py | 0.647018 | 0.265613 | CameraPredictivePitchHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PlayerRespawn(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PlayerRespawn]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PlayerRespawn(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PlayerRespawn.py | 0.61451 | 0.265154 | PlayerRespawn.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class Waypoint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[Waypoint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return Waypoint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/Waypoint.py | 0.611846 | 0.264032 | Waypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class HealthPhases(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[HealthPhases]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return HealthPhases(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/HealthPhases.py | 0.612194 | 0.2587 | HealthPhases.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AngleCompare(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AngleCompare]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AngleCompare(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AngleCompare.py | 0.614741 | 0.254938 | AngleCompare.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class RetronomeDriver(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[RetronomeDriver]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return RetronomeDriver(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/RetronomeDriver.py | 0.601945 | 0.265797 | RetronomeDriver.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ProjectedShadowBlob(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ProjectedShadowBlob]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ProjectedShadowBlob(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ProjectedShadowBlob.py | 0.610337 | 0.24939 | ProjectedShadowBlob.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ActorInteraction(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ActorInteraction]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ActorInteraction(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ActorInteraction.py | 0.614857 | 0.256692 | ActorInteraction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class ColorGrade(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[ColorGrade]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return ColorGrade(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/ColorGrade.py | 0.649912 | 0.258268 | ColorGrade.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class AudioSampleBank(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[AudioSampleBank]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return AudioSampleBank(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/AudioSampleBank.py | 0.614741 | 0.263173 | AudioSampleBank.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class FactionManager(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[FactionManager]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return FactionManager(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/FactionManager.py | 0.602646 | 0.256046 | FactionManager.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class TimerSequence(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[TimerSequence]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return TimerSequence(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/TimerSequence.py | 0.620277 | 0.264269 | TimerSequence.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class PerformanceHint(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[PerformanceHint]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return PerformanceHint(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/PerformanceHint.py | 0.619471 | 0.255826 | PerformanceHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class EyeBallMP1(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[EyeBallMP1]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return EyeBallMP1(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/EyeBallMP1.py | 0.604399 | 0.263499 | EyeBallMP1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class CreatureAttackPathBehavior(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[CreatureAttackPathBehavior]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return CreatureAttackPathBehavior(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/CreatureAttackPathBehavior.py | 0.611614 | 0.261213 | CreatureAttackPathBehavior.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseProperty
import base64
@dataclasses.dataclass()
class MIDIMatcher(BaseProperty):
unknown_properties: dict[int, bytes] = dataclasses.field(default_factory=dict)
@classmethod
def game(cls) -> Game:
return Game.PRIME_REMASTER
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
property_count = struct.unpack("<H", data.read(2))[0]
if default_override is None and (result := _fast_decode(data, property_count)) is not None:
return result
present_fields = default_override or {}
present_fields["unknown_properties"] = {}
for _ in range(property_count):
property_id, property_size = struct.unpack("<LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
present_fields["unknown_properties"][property_id] = data.read(property_size)
assert data.tell() - start == property_size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(struct.pack("<H", 0 + len(self.unknown_properties)))
for property_id, property_data in self.unknown_properties.items():
data.write(struct.pack("<LH", property_id, len(property_data)))
data.write(property_data)
@classmethod
def from_json(cls, data: dict):
return cls(
unknown_properties={
int(property_id, 16): base64.b64decode(property_data)
for property_id, property_data in data["unknown_properties"].items()
},
)
def to_json(self) -> dict:
return {
'unknown_properties': {
hex(property_id): base64.b64encode(property_data)
for property_id, property_data in self.unknown_properties.items()
}
}
_FAST_FORMAT = None
_FAST_IDS = ()
def _fast_decode(data: typing.BinaryIO, property_count: int) -> typing.Optional[MIDIMatcher]:
if property_count != 0:
return None
global _FAST_FORMAT
if _FAST_FORMAT is None:
_FAST_FORMAT = struct.Struct('<')
before = data.tell()
dec = _FAST_FORMAT.unpack(data.read(0))
if () != _FAST_IDS:
data.seek(before)
return None
return MIDIMatcher(
)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/prime_remastered/objects/MIDIMatcher.py | 0.606615 | 0.256716 | MIDIMatcher.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.