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.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct10 import UnknownStruct10
from retro_data_structures.properties.echoes.archetypes.UnknownStruct11 import UnknownStruct11
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class CommandoPirate(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
sound: int = dataclasses.field(default=0)
aggressiveness: float = dataclasses.field(default=10.0)
cover_check: float = dataclasses.field(default=50.0)
search_radius: float = dataclasses.field(default=30.0)
dodge_check: float = dataclasses.field(default=80.0)
sound_impact: int = dataclasses.field(default=0, metadata={'sound': True})
sound_hurled: int = dataclasses.field(default=0, metadata={'sound': True})
sound_death: int = dataclasses.field(default=0, metadata={'sound': True})
always_ff_0xfca76593: int = dataclasses.field(default=0)
always_ff_0x467c3d94: int = dataclasses.field(default=0)
blade_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_projectile: int = dataclasses.field(default=0, metadata={'sound': True})
hearing_radius: float = dataclasses.field(default=20.0)
unknown_struct10: UnknownStruct10 = dataclasses.field(default_factory=UnknownStruct10)
unknown_struct11: UnknownStruct11 = dataclasses.field(default_factory=UnknownStruct11)
unknown_0x71587b45: float = dataclasses.field(default=0.10000000149011612)
unknown_0x7903312e: float = dataclasses.field(default=0.05000000074505806)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CMDO'
@classmethod
def modules(cls) -> typing.List[str]:
return ['PirateRagDoll.rel', 'CommandoPirate.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0, 'detection_angle': 90.0, 'average_attack_time': 1.0, 'attack_time_variation': 0.5, 'damage_wait_time': 3.0, 'collision_radius': 0.800000011920929, 'collision_height': 3.0, 'step_up_height': 0.30000001192092896, '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'\xe6\x17H\xed') # 0xe61748ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_possession_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'z\xbe\xd4\xce') # 0x7abed4ce
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'\x95y\xb1\xf2') # 0x9579b1f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.aggressiveness))
data.write(b'\xf8\x9a\xb4\x19') # 0xf89ab419
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cover_check))
data.write(b'\xed\x9b\xf5\xa3') # 0xed9bf5a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.search_radius))
data.write(b'\xdc6\xe7E') # 0xdc36e745
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dodge_check))
data.write(b'\x1b\xb1n\xa5') # 0x1bb16ea5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_impact))
data.write(b';\xb3z\x8f') # 0x3bb37a8f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_hurled))
data.write(b'\xe1`\xb5\x93') # 0xe160b593
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_death))
data.write(b'\xfc\xa7e\x93') # 0xfca76593
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.always_ff_0xfca76593))
data.write(b'F|=\x94') # 0x467c3d94
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.always_ff_0x467c3d94))
data.write(b'\xa5\x91$0') # 0xa5912430
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.blade_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 10.0, 'di_knock_back_power': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile))
data.write(b'U;\x139') # 0x553b1339
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xea\xc2v\x05') # 0xeac27605
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_projectile))
data.write(b'\xediH\x8f') # 0xed69488f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hearing_radius))
data.write(b'\xfbCRW') # 0xfb435257
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct10.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'8\x8e\x16\xc9') # 0x388e16c9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct11.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'qX{E') # 0x71587b45
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x71587b45))
data.write(b'y\x031.') # 0x7903312e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x7903312e))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
ing_possession_data=IngPossessionData.from_json(data['ing_possession_data']),
sound=data['sound'],
aggressiveness=data['aggressiveness'],
cover_check=data['cover_check'],
search_radius=data['search_radius'],
dodge_check=data['dodge_check'],
sound_impact=data['sound_impact'],
sound_hurled=data['sound_hurled'],
sound_death=data['sound_death'],
always_ff_0xfca76593=data['always_ff_0xfca76593'],
always_ff_0x467c3d94=data['always_ff_0x467c3d94'],
blade_damage=DamageInfo.from_json(data['blade_damage']),
projectile=data['projectile'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
sound_projectile=data['sound_projectile'],
hearing_radius=data['hearing_radius'],
unknown_struct10=UnknownStruct10.from_json(data['unknown_struct10']),
unknown_struct11=UnknownStruct11.from_json(data['unknown_struct11']),
unknown_0x71587b45=data['unknown_0x71587b45'],
unknown_0x7903312e=data['unknown_0x7903312e'],
)
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(),
'ing_possession_data': self.ing_possession_data.to_json(),
'sound': self.sound,
'aggressiveness': self.aggressiveness,
'cover_check': self.cover_check,
'search_radius': self.search_radius,
'dodge_check': self.dodge_check,
'sound_impact': self.sound_impact,
'sound_hurled': self.sound_hurled,
'sound_death': self.sound_death,
'always_ff_0xfca76593': self.always_ff_0xfca76593,
'always_ff_0x467c3d94': self.always_ff_0x467c3d94,
'blade_damage': self.blade_damage.to_json(),
'projectile': self.projectile,
'projectile_damage': self.projectile_damage.to_json(),
'sound_projectile': self.sound_projectile,
'hearing_radius': self.hearing_radius,
'unknown_struct10': self.unknown_struct10.to_json(),
'unknown_struct11': self.unknown_struct11.to_json(),
'unknown_0x71587b45': self.unknown_0x71587b45,
'unknown_0x7903312e': self.unknown_0x7903312e,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def _dependencies_for_sound_impact(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_impact)
def _dependencies_for_sound_hurled(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_hurled)
def _dependencies_for_sound_death(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_death)
def _dependencies_for_blade_damage(self, asset_manager):
yield from self.blade_damage.dependencies_for(asset_manager)
def _dependencies_for_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_projectile(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_projectile)
def _dependencies_for_unknown_struct10(self, asset_manager):
yield from self.unknown_struct10.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct11(self, asset_manager):
yield from self.unknown_struct11.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
(self._dependencies_for_sound_impact, "sound_impact", "int"),
(self._dependencies_for_sound_hurled, "sound_hurled", "int"),
(self._dependencies_for_sound_death, "sound_death", "int"),
(self._dependencies_for_blade_damage, "blade_damage", "DamageInfo"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
(self._dependencies_for_sound_projectile, "sound_projectile", "int"),
(self._dependencies_for_unknown_struct10, "unknown_struct10", "UnknownStruct10"),
(self._dependencies_for_unknown_struct11, "unknown_struct11", "UnknownStruct11"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CommandoPirate.{field_name} ({field_type}): {e}"
)
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, 'detection_angle': 90.0, 'average_attack_time': 1.0, 'attack_time_variation': 0.5, 'damage_wait_time': 3.0, 'collision_radius': 0.800000011920929, 'collision_height': 3.0, 'step_up_height': 0.30000001192092896, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_ing_possession_data(data: typing.BinaryIO, property_size: int):
return IngPossessionData.from_stream(data, property_size)
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_aggressiveness(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cover_check(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_search_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dodge_check(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_impact(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_hurled(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_death(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_always_ff_0xfca76593(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_always_ff_0x467c3d94(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_blade_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 10.0, 'di_knock_back_power': 5.0})
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
def _decode_sound_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_hearing_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct10(data: typing.BinaryIO, property_size: int):
return UnknownStruct10.from_stream(data, property_size)
def _decode_unknown_struct11(data: typing.BinaryIO, property_size: int):
return UnknownStruct11.from_stream(data, property_size)
def _decode_unknown_0x71587b45(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x7903312e(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
0x7abed4ce: ('sound', _decode_sound),
0x9579b1f2: ('aggressiveness', _decode_aggressiveness),
0xf89ab419: ('cover_check', _decode_cover_check),
0xed9bf5a3: ('search_radius', _decode_search_radius),
0xdc36e745: ('dodge_check', _decode_dodge_check),
0x1bb16ea5: ('sound_impact', _decode_sound_impact),
0x3bb37a8f: ('sound_hurled', _decode_sound_hurled),
0xe160b593: ('sound_death', _decode_sound_death),
0xfca76593: ('always_ff_0xfca76593', _decode_always_ff_0xfca76593),
0x467c3d94: ('always_ff_0x467c3d94', _decode_always_ff_0x467c3d94),
0xa5912430: ('blade_damage', _decode_blade_damage),
0xef485db9: ('projectile', _decode_projectile),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0xeac27605: ('sound_projectile', _decode_sound_projectile),
0xed69488f: ('hearing_radius', _decode_hearing_radius),
0xfb435257: ('unknown_struct10', _decode_unknown_struct10),
0x388e16c9: ('unknown_struct11', _decode_unknown_struct11),
0x71587b45: ('unknown_0x71587b45', _decode_unknown_0x71587b45),
0x7903312e: ('unknown_0x7903312e', _decode_unknown_0x7903312e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CommandoPirate.py | 0.562898 | 0.232724 | CommandoPirate.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.archetypes.VisorParameters import VisorParameters
@dataclasses.dataclass()
class DamageableTriggerOrientated(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
orbitable: bool = dataclasses.field(default=False)
enable_seeker_lock_on: bool = dataclasses.field(default=False)
invulnerable: bool = dataclasses.field(default=False)
visor: VisorParameters = dataclasses.field(default_factory=VisorParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DTRO'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\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'\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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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'],
visor=VisorParameters.from_json(data['visor']),
)
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,
'visor': self.visor.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_visor(self, asset_manager):
yield from self.visor.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_visor, "visor", "VisorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DamageableTriggerOrientated.{field_name} ({field_type}): {e}"
)
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_visor(data: typing.BinaryIO, property_size: int):
return VisorParameters.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x704b5369: ('orbitable', _decode_orbitable),
0x5dfd7820: ('enable_seeker_lock_on', _decode_enable_seeker_lock_on),
0x6652bdd7: ('invulnerable', _decode_invulnerable),
0x5ad250e: ('visor', _decode_visor),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DamageableTriggerOrientated.py | 0.568296 | 0.33805 | DamageableTriggerOrientated.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.TriggerInfo import TriggerInfo
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Steam(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
steam: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
strength: float = dataclasses.field(default=0.3499999940395355)
fade_in_rate: float = dataclasses.field(default=1.0)
fade_out_rate: float = dataclasses.field(default=2.0)
radius: float = dataclasses.field(default=0.0)
unknown: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'STEM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'&4`P') # 0x26346050
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.steam))
data.write(b'O\x8f_\\') # 0x4f8f5f5c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.strength))
data.write(b'\xc2\x13\x8f=') # 0xc2138f3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_rate))
data.write(b'.\x9f%\x9e') # 0x2e9f259e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_rate))
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'\xa3f\xc9I') # 0xa366c949
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
trigger=TriggerInfo.from_json(data['trigger']),
steam=data['steam'],
strength=data['strength'],
fade_in_rate=data['fade_in_rate'],
fade_out_rate=data['fade_out_rate'],
radius=data['radius'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger': self.trigger.to_json(),
'steam': self.steam,
'strength': self.strength,
'fade_in_rate': self.fade_in_rate,
'fade_out_rate': self.fade_out_rate,
'radius': self.radius,
'unknown': self.unknown,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_trigger(self, asset_manager):
yield from self.trigger.dependencies_for(asset_manager)
def _dependencies_for_steam(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.steam)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_trigger, "trigger", "TriggerInfo"),
(self._dependencies_for_steam, "steam", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Steam.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_steam(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_strength(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown(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),
0x77a27411: ('trigger', _decode_trigger),
0x26346050: ('steam', _decode_steam),
0x4f8f5f5c: ('strength', _decode_strength),
0xc2138f3d: ('fade_in_rate', _decode_fade_in_rate),
0x2e9f259e: ('fade_out_rate', _decode_fade_out_rate),
0x78c507eb: ('radius', _decode_radius),
0xa366c949: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Steam.py | 0.553747 | 0.289836 | Steam.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.BasicSwarmProperties import BasicSwarmProperties
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class MetareeSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
basic_swarm_properties: BasicSwarmProperties = dataclasses.field(default_factory=BasicSwarmProperties)
unknown_0x7399abbb: int = dataclasses.field(default=0)
unknown_0x734d923b: int = dataclasses.field(default=0)
max_attack_angle: float = dataclasses.field(default=30.0)
into_attack_speed: float = dataclasses.field(default=1.0)
attack_speed: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MSWM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SwarmBasics.rel', 'MetareeSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'~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'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'\xe1\xecsF') # 0xe1ec7346
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.basic_swarm_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\x99\xab\xbb') # 0x7399abbb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7399abbb))
data.write(b'sM\x92;') # 0x734d923b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x734d923b))
data.write(b'\xf1\x1fs\x84') # 0xf11f7384
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_angle))
data.write(b'\xcav\x1d\xcd') # 0xca761dcd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.into_attack_speed))
data.write(b'l\n+\xc8') # 0x6c0a2bc8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_speed))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
animation_information=AnimationParameters.from_json(data['animation_information']),
active=data['active'],
basic_swarm_properties=BasicSwarmProperties.from_json(data['basic_swarm_properties']),
unknown_0x7399abbb=data['unknown_0x7399abbb'],
unknown_0x734d923b=data['unknown_0x734d923b'],
max_attack_angle=data['max_attack_angle'],
into_attack_speed=data['into_attack_speed'],
attack_speed=data['attack_speed'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'animation_information': self.animation_information.to_json(),
'active': self.active,
'basic_swarm_properties': self.basic_swarm_properties.to_json(),
'unknown_0x7399abbb': self.unknown_0x7399abbb,
'unknown_0x734d923b': self.unknown_0x734d923b,
'max_attack_angle': self.max_attack_angle,
'into_attack_speed': self.into_attack_speed,
'attack_speed': self.attack_speed,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_basic_swarm_properties(self, asset_manager):
yield from self.basic_swarm_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_basic_swarm_properties, "basic_swarm_properties", "BasicSwarmProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MetareeSwarm.{field_name} ({field_type}): {e}"
)
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_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_basic_swarm_properties(data: typing.BinaryIO, property_size: int):
return BasicSwarmProperties.from_stream(data, property_size)
def _decode_unknown_0x7399abbb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x734d923b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_attack_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_into_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_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),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xc6bb2f45: ('active', _decode_active),
0xe1ec7346: ('basic_swarm_properties', _decode_basic_swarm_properties),
0x7399abbb: ('unknown_0x7399abbb', _decode_unknown_0x7399abbb),
0x734d923b: ('unknown_0x734d923b', _decode_unknown_0x734d923b),
0xf11f7384: ('max_attack_angle', _decode_max_attack_angle),
0xca761dcd: ('into_attack_speed', _decode_into_attack_speed),
0x6c0a2bc8: ('attack_speed', _decode_attack_speed),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/MetareeSwarm.py | 0.602763 | 0.293158 | MetareeSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.SpindleCameraStruct import SpindleCameraStruct
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class SpindleCamera(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_spindle_camera: int = dataclasses.field(default=6400)
spindle_camera_struct_0xe56495fb: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x239debfc: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x27e8d703: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x2f914525: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x23aa31b7: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0xe9e388af: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0xde5a2c87: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x1b3b2394: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0xf5666b6e: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x66c618aa: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0xb36d0fb6: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0xcbb013cb: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x4abfb789: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0xfb6a407a: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x3ae66f80: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
spindle_camera_struct_0x6654ae92: SpindleCameraStruct = dataclasses.field(default_factory=SpindleCameraStruct)
target_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
unknown_0x33b4f106: bool = dataclasses.field(default=False)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
unknown_0x431769c6: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPND'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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';\xf4\xeb\xa8') # 0x3bf4eba8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_spindle_camera))
data.write(b'\xe5d\x95\xfb') # 0xe56495fb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xe56495fb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#\x9d\xeb\xfc') # 0x239debfc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x239debfc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"'\xe8\xd7\x03") # 0x27e8d703
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x27e8d703.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'/\x91E%') # 0x2f914525
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x2f914525.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'#\xaa1\xb7') # 0x23aa31b7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x23aa31b7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe9\xe3\x88\xaf') # 0xe9e388af
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xe9e388af.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdeZ,\x87') # 0xde5a2c87
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xde5a2c87.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b;#\x94') # 0x1b3b2394
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x1b3b2394.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5fkn') # 0xf5666b6e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xf5666b6e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'f\xc6\x18\xaa') # 0x66c618aa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x66c618aa.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3m\x0f\xb6') # 0xb36d0fb6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xb36d0fb6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\xb0\x13\xcb') # 0xcbb013cb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xcbb013cb.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\xbf\xb7\x89') # 0x4abfb789
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x4abfb789.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfbj@z') # 0xfb6a407a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0xfb6a407a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b':\xe6o\x80') # 0x3ae66f80
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x3ae66f80.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'fT\xae\x92') # 0x6654ae92
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spindle_camera_struct_0x6654ae92.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\x04\xd3\x04') # 0x5604d304
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_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'3\xb4\xf1\x06') # 0x33b4f106
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x33b4f106))
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'3\xe4h[') # 0x33e4685b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\x17i\xc6') # 0x431769c6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x431769c6))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_spindle_camera=data['flags_spindle_camera'],
spindle_camera_struct_0xe56495fb=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xe56495fb']),
spindle_camera_struct_0x239debfc=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x239debfc']),
spindle_camera_struct_0x27e8d703=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x27e8d703']),
spindle_camera_struct_0x2f914525=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x2f914525']),
spindle_camera_struct_0x23aa31b7=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x23aa31b7']),
spindle_camera_struct_0xe9e388af=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xe9e388af']),
spindle_camera_struct_0xde5a2c87=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xde5a2c87']),
spindle_camera_struct_0x1b3b2394=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x1b3b2394']),
spindle_camera_struct_0xf5666b6e=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xf5666b6e']),
spindle_camera_struct_0x66c618aa=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x66c618aa']),
spindle_camera_struct_0xb36d0fb6=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xb36d0fb6']),
spindle_camera_struct_0xcbb013cb=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xcbb013cb']),
spindle_camera_struct_0x4abfb789=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x4abfb789']),
spindle_camera_struct_0xfb6a407a=SpindleCameraStruct.from_json(data['spindle_camera_struct_0xfb6a407a']),
spindle_camera_struct_0x3ae66f80=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x3ae66f80']),
spindle_camera_struct_0x6654ae92=SpindleCameraStruct.from_json(data['spindle_camera_struct_0x6654ae92']),
target_spline_type=SplineType.from_json(data['target_spline_type']),
unknown_0x33b4f106=data['unknown_0x33b4f106'],
target_control_spline=Spline.from_json(data['target_control_spline']),
spline_type=SplineType.from_json(data['spline_type']),
unknown_0x431769c6=data['unknown_0x431769c6'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_spindle_camera': self.flags_spindle_camera,
'spindle_camera_struct_0xe56495fb': self.spindle_camera_struct_0xe56495fb.to_json(),
'spindle_camera_struct_0x239debfc': self.spindle_camera_struct_0x239debfc.to_json(),
'spindle_camera_struct_0x27e8d703': self.spindle_camera_struct_0x27e8d703.to_json(),
'spindle_camera_struct_0x2f914525': self.spindle_camera_struct_0x2f914525.to_json(),
'spindle_camera_struct_0x23aa31b7': self.spindle_camera_struct_0x23aa31b7.to_json(),
'spindle_camera_struct_0xe9e388af': self.spindle_camera_struct_0xe9e388af.to_json(),
'spindle_camera_struct_0xde5a2c87': self.spindle_camera_struct_0xde5a2c87.to_json(),
'spindle_camera_struct_0x1b3b2394': self.spindle_camera_struct_0x1b3b2394.to_json(),
'spindle_camera_struct_0xf5666b6e': self.spindle_camera_struct_0xf5666b6e.to_json(),
'spindle_camera_struct_0x66c618aa': self.spindle_camera_struct_0x66c618aa.to_json(),
'spindle_camera_struct_0xb36d0fb6': self.spindle_camera_struct_0xb36d0fb6.to_json(),
'spindle_camera_struct_0xcbb013cb': self.spindle_camera_struct_0xcbb013cb.to_json(),
'spindle_camera_struct_0x4abfb789': self.spindle_camera_struct_0x4abfb789.to_json(),
'spindle_camera_struct_0xfb6a407a': self.spindle_camera_struct_0xfb6a407a.to_json(),
'spindle_camera_struct_0x3ae66f80': self.spindle_camera_struct_0x3ae66f80.to_json(),
'spindle_camera_struct_0x6654ae92': self.spindle_camera_struct_0x6654ae92.to_json(),
'target_spline_type': self.target_spline_type.to_json(),
'unknown_0x33b4f106': self.unknown_0x33b4f106,
'target_control_spline': self.target_control_spline.to_json(),
'spline_type': self.spline_type.to_json(),
'unknown_0x431769c6': self.unknown_0x431769c6,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xe56495fb(self, asset_manager):
yield from self.spindle_camera_struct_0xe56495fb.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x239debfc(self, asset_manager):
yield from self.spindle_camera_struct_0x239debfc.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x27e8d703(self, asset_manager):
yield from self.spindle_camera_struct_0x27e8d703.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x2f914525(self, asset_manager):
yield from self.spindle_camera_struct_0x2f914525.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x23aa31b7(self, asset_manager):
yield from self.spindle_camera_struct_0x23aa31b7.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xe9e388af(self, asset_manager):
yield from self.spindle_camera_struct_0xe9e388af.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xde5a2c87(self, asset_manager):
yield from self.spindle_camera_struct_0xde5a2c87.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x1b3b2394(self, asset_manager):
yield from self.spindle_camera_struct_0x1b3b2394.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xf5666b6e(self, asset_manager):
yield from self.spindle_camera_struct_0xf5666b6e.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x66c618aa(self, asset_manager):
yield from self.spindle_camera_struct_0x66c618aa.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xb36d0fb6(self, asset_manager):
yield from self.spindle_camera_struct_0xb36d0fb6.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xcbb013cb(self, asset_manager):
yield from self.spindle_camera_struct_0xcbb013cb.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x4abfb789(self, asset_manager):
yield from self.spindle_camera_struct_0x4abfb789.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0xfb6a407a(self, asset_manager):
yield from self.spindle_camera_struct_0xfb6a407a.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x3ae66f80(self, asset_manager):
yield from self.spindle_camera_struct_0x3ae66f80.dependencies_for(asset_manager)
def _dependencies_for_spindle_camera_struct_0x6654ae92(self, asset_manager):
yield from self.spindle_camera_struct_0x6654ae92.dependencies_for(asset_manager)
def _dependencies_for_target_spline_type(self, asset_manager):
yield from self.target_spline_type.dependencies_for(asset_manager)
def _dependencies_for_spline_type(self, asset_manager):
yield from self.spline_type.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_spindle_camera_struct_0xe56495fb, "spindle_camera_struct_0xe56495fb", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x239debfc, "spindle_camera_struct_0x239debfc", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x27e8d703, "spindle_camera_struct_0x27e8d703", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x2f914525, "spindle_camera_struct_0x2f914525", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x23aa31b7, "spindle_camera_struct_0x23aa31b7", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0xe9e388af, "spindle_camera_struct_0xe9e388af", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0xde5a2c87, "spindle_camera_struct_0xde5a2c87", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x1b3b2394, "spindle_camera_struct_0x1b3b2394", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0xf5666b6e, "spindle_camera_struct_0xf5666b6e", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x66c618aa, "spindle_camera_struct_0x66c618aa", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0xb36d0fb6, "spindle_camera_struct_0xb36d0fb6", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0xcbb013cb, "spindle_camera_struct_0xcbb013cb", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x4abfb789, "spindle_camera_struct_0x4abfb789", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0xfb6a407a, "spindle_camera_struct_0xfb6a407a", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x3ae66f80, "spindle_camera_struct_0x3ae66f80", "SpindleCameraStruct"),
(self._dependencies_for_spindle_camera_struct_0x6654ae92, "spindle_camera_struct_0x6654ae92", "SpindleCameraStruct"),
(self._dependencies_for_target_spline_type, "target_spline_type", "SplineType"),
(self._dependencies_for_spline_type, "spline_type", "SplineType"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpindleCamera.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_spindle_camera(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spindle_camera_struct_0xe56495fb(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x239debfc(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x27e8d703(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x2f914525(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x23aa31b7(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0xe9e388af(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0xde5a2c87(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x1b3b2394(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0xf5666b6e(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x66c618aa(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0xb36d0fb6(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0xcbb013cb(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x4abfb789(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0xfb6a407a(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x3ae66f80(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_spindle_camera_struct_0x6654ae92(data: typing.BinaryIO, property_size: int):
return SpindleCameraStruct.from_stream(data, property_size)
def _decode_target_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_unknown_0x33b4f106(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_unknown_0x431769c6(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),
0x3bf4eba8: ('flags_spindle_camera', _decode_flags_spindle_camera),
0xe56495fb: ('spindle_camera_struct_0xe56495fb', _decode_spindle_camera_struct_0xe56495fb),
0x239debfc: ('spindle_camera_struct_0x239debfc', _decode_spindle_camera_struct_0x239debfc),
0x27e8d703: ('spindle_camera_struct_0x27e8d703', _decode_spindle_camera_struct_0x27e8d703),
0x2f914525: ('spindle_camera_struct_0x2f914525', _decode_spindle_camera_struct_0x2f914525),
0x23aa31b7: ('spindle_camera_struct_0x23aa31b7', _decode_spindle_camera_struct_0x23aa31b7),
0xe9e388af: ('spindle_camera_struct_0xe9e388af', _decode_spindle_camera_struct_0xe9e388af),
0xde5a2c87: ('spindle_camera_struct_0xde5a2c87', _decode_spindle_camera_struct_0xde5a2c87),
0x1b3b2394: ('spindle_camera_struct_0x1b3b2394', _decode_spindle_camera_struct_0x1b3b2394),
0xf5666b6e: ('spindle_camera_struct_0xf5666b6e', _decode_spindle_camera_struct_0xf5666b6e),
0x66c618aa: ('spindle_camera_struct_0x66c618aa', _decode_spindle_camera_struct_0x66c618aa),
0xb36d0fb6: ('spindle_camera_struct_0xb36d0fb6', _decode_spindle_camera_struct_0xb36d0fb6),
0xcbb013cb: ('spindle_camera_struct_0xcbb013cb', _decode_spindle_camera_struct_0xcbb013cb),
0x4abfb789: ('spindle_camera_struct_0x4abfb789', _decode_spindle_camera_struct_0x4abfb789),
0xfb6a407a: ('spindle_camera_struct_0xfb6a407a', _decode_spindle_camera_struct_0xfb6a407a),
0x3ae66f80: ('spindle_camera_struct_0x3ae66f80', _decode_spindle_camera_struct_0x3ae66f80),
0x6654ae92: ('spindle_camera_struct_0x6654ae92', _decode_spindle_camera_struct_0x6654ae92),
0x5604d304: ('target_spline_type', _decode_target_spline_type),
0x33b4f106: ('unknown_0x33b4f106', _decode_unknown_0x33b4f106),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0x33e4685b: ('spline_type', _decode_spline_type),
0x431769c6: ('unknown_0x431769c6', _decode_unknown_0x431769c6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SpindleCamera.py | 0.576542 | 0.315182 | SpindleCamera.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.CameraShakerData import CameraShakerData
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.Arm.Position import Position
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.Beam.Misc import Misc
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.Holstering import Holstering
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.Misc import Misc
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.Position import Position
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.RicochetDamage.Factor import Factor
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.UnknownStruct1 import UnknownStruct1
from retro_data_structures.properties.echoes.archetypes.TweakPlayerGun.Weapons import Weapons
@dataclasses.dataclass()
class TweakPlayerGun(BaseObjectType):
instance_name: str = dataclasses.field(default='')
misc: Misc = dataclasses.field(default_factory=Misc)
holstering: Holstering = dataclasses.field(default_factory=Holstering)
position: Position = dataclasses.field(default_factory=Position)
arm_position: Position = dataclasses.field(default_factory=Position)
weapons: Weapons = dataclasses.field(default_factory=Weapons)
combos: UnknownStruct1 = dataclasses.field(default_factory=UnknownStruct1)
beam_misc: Misc = dataclasses.field(default_factory=Misc)
ricochet_damage_factor: Factor = dataclasses.field(default_factory=Factor)
recoil: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
combo_recoil: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
projectile_recoil: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
flame_thrower: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
wave_buster: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
projectile_impact: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWPM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb8.\xd4$') # 0xb82ed424
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.misc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'kk\xdcG') # 0x6b6bdc47
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.holstering.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x87\x88,\xb0') # 0x87882cb0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.position.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'%P\x07\xad') # 0x255007ad
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.arm_position.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x83\xd7X\xab') # 0x83d758ab
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weapons.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x88\x8c\x87u') # 0x888c8775
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.combos.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\xeb\xb7>') # 0xaaebb73e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.beam_misc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d\xa0X\xfe') # 0x8da058fe
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ricochet_damage_factor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xff\xdbK\xb7') # 0xffdb4bb7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.recoil.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x93z5\xbd') # 0x937a35bd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.combo_recoil.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'&\x19g8') # 0x26196738
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_recoil.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf4\x08\x08\xc9') # 0xf40808c9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flame_thrower.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9amz1') # 0x9a6d7a31
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.wave_buster.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\xf1LZ') # 0x12f14c5a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_impact.to_stream(data, default_override={'flags_camera_shaker': 19})
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(
instance_name=data['instance_name'],
misc=Misc.from_json(data['misc']),
holstering=Holstering.from_json(data['holstering']),
position=Position.from_json(data['position']),
arm_position=Position.from_json(data['arm_position']),
weapons=Weapons.from_json(data['weapons']),
combos=UnknownStruct1.from_json(data['combos']),
beam_misc=Misc.from_json(data['beam_misc']),
ricochet_damage_factor=Factor.from_json(data['ricochet_damage_factor']),
recoil=CameraShakerData.from_json(data['recoil']),
combo_recoil=CameraShakerData.from_json(data['combo_recoil']),
projectile_recoil=CameraShakerData.from_json(data['projectile_recoil']),
flame_thrower=CameraShakerData.from_json(data['flame_thrower']),
wave_buster=CameraShakerData.from_json(data['wave_buster']),
projectile_impact=CameraShakerData.from_json(data['projectile_impact']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'misc': self.misc.to_json(),
'holstering': self.holstering.to_json(),
'position': self.position.to_json(),
'arm_position': self.arm_position.to_json(),
'weapons': self.weapons.to_json(),
'combos': self.combos.to_json(),
'beam_misc': self.beam_misc.to_json(),
'ricochet_damage_factor': self.ricochet_damage_factor.to_json(),
'recoil': self.recoil.to_json(),
'combo_recoil': self.combo_recoil.to_json(),
'projectile_recoil': self.projectile_recoil.to_json(),
'flame_thrower': self.flame_thrower.to_json(),
'wave_buster': self.wave_buster.to_json(),
'projectile_impact': self.projectile_impact.to_json(),
}
def _dependencies_for_misc(self, asset_manager):
yield from self.misc.dependencies_for(asset_manager)
def _dependencies_for_holstering(self, asset_manager):
yield from self.holstering.dependencies_for(asset_manager)
def _dependencies_for_position(self, asset_manager):
yield from self.position.dependencies_for(asset_manager)
def _dependencies_for_arm_position(self, asset_manager):
yield from self.arm_position.dependencies_for(asset_manager)
def _dependencies_for_weapons(self, asset_manager):
yield from self.weapons.dependencies_for(asset_manager)
def _dependencies_for_combos(self, asset_manager):
yield from self.combos.dependencies_for(asset_manager)
def _dependencies_for_beam_misc(self, asset_manager):
yield from self.beam_misc.dependencies_for(asset_manager)
def _dependencies_for_ricochet_damage_factor(self, asset_manager):
yield from self.ricochet_damage_factor.dependencies_for(asset_manager)
def _dependencies_for_recoil(self, asset_manager):
yield from self.recoil.dependencies_for(asset_manager)
def _dependencies_for_combo_recoil(self, asset_manager):
yield from self.combo_recoil.dependencies_for(asset_manager)
def _dependencies_for_projectile_recoil(self, asset_manager):
yield from self.projectile_recoil.dependencies_for(asset_manager)
def _dependencies_for_flame_thrower(self, asset_manager):
yield from self.flame_thrower.dependencies_for(asset_manager)
def _dependencies_for_wave_buster(self, asset_manager):
yield from self.wave_buster.dependencies_for(asset_manager)
def _dependencies_for_projectile_impact(self, asset_manager):
yield from self.projectile_impact.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_misc, "misc", "Misc"),
(self._dependencies_for_holstering, "holstering", "Holstering"),
(self._dependencies_for_position, "position", "Position"),
(self._dependencies_for_arm_position, "arm_position", "Position"),
(self._dependencies_for_weapons, "weapons", "Weapons"),
(self._dependencies_for_combos, "combos", "UnknownStruct1"),
(self._dependencies_for_beam_misc, "beam_misc", "Misc"),
(self._dependencies_for_ricochet_damage_factor, "ricochet_damage_factor", "Factor"),
(self._dependencies_for_recoil, "recoil", "CameraShakerData"),
(self._dependencies_for_combo_recoil, "combo_recoil", "CameraShakerData"),
(self._dependencies_for_projectile_recoil, "projectile_recoil", "CameraShakerData"),
(self._dependencies_for_flame_thrower, "flame_thrower", "CameraShakerData"),
(self._dependencies_for_wave_buster, "wave_buster", "CameraShakerData"),
(self._dependencies_for_projectile_impact, "projectile_impact", "CameraShakerData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakPlayerGun.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_misc(data: typing.BinaryIO, property_size: int):
return Misc.from_stream(data, property_size)
def _decode_holstering(data: typing.BinaryIO, property_size: int):
return Holstering.from_stream(data, property_size)
def _decode_position(data: typing.BinaryIO, property_size: int):
return Position.from_stream(data, property_size)
def _decode_arm_position(data: typing.BinaryIO, property_size: int):
return Position.from_stream(data, property_size)
def _decode_weapons(data: typing.BinaryIO, property_size: int):
return Weapons.from_stream(data, property_size)
def _decode_combos(data: typing.BinaryIO, property_size: int):
return UnknownStruct1.from_stream(data, property_size)
def _decode_beam_misc(data: typing.BinaryIO, property_size: int):
return Misc.from_stream(data, property_size)
def _decode_ricochet_damage_factor(data: typing.BinaryIO, property_size: int):
return Factor.from_stream(data, property_size)
def _decode_recoil(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
def _decode_combo_recoil(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
def _decode_projectile_recoil(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
def _decode_flame_thrower(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
def _decode_wave_buster(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
def _decode_projectile_impact(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size, default_override={'flags_camera_shaker': 19})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0xb82ed424: ('misc', _decode_misc),
0x6b6bdc47: ('holstering', _decode_holstering),
0x87882cb0: ('position', _decode_position),
0x255007ad: ('arm_position', _decode_arm_position),
0x83d758ab: ('weapons', _decode_weapons),
0x888c8775: ('combos', _decode_combos),
0xaaebb73e: ('beam_misc', _decode_beam_misc),
0x8da058fe: ('ricochet_damage_factor', _decode_ricochet_damage_factor),
0xffdb4bb7: ('recoil', _decode_recoil),
0x937a35bd: ('combo_recoil', _decode_combo_recoil),
0x26196738: ('projectile_recoil', _decode_projectile_recoil),
0xf40808c9: ('flame_thrower', _decode_flame_thrower),
0x9a6d7a31: ('wave_buster', _decode_wave_buster),
0x12f14c5a: ('projectile_impact', _decode_projectile_impact),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakPlayerGun.py | 0.532911 | 0.259063 | TweakPlayerGun.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RadialDamage(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
radius: float = dataclasses.field(default=15.0)
auto_action: bool = dataclasses.field(default=False)
auto_delete: bool = dataclasses.field(default=False)
originator: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RADD'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'3\x7f\x95$') # 0x337f9524
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'8\x8e]\xd3') # 0x388e5dd3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_action))
data.write(b'\xdb\x82l\xbe') # 0xdb826cbe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_delete))
data.write(b'\x9c\x95\x1f\xed') # 0x9c951fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.originator))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
damage=DamageInfo.from_json(data['damage']),
radius=data['radius'],
auto_action=data['auto_action'],
auto_delete=data['auto_delete'],
originator=data['originator'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'damage': self.damage.to_json(),
'radius': self.radius,
'auto_action': self.auto_action,
'auto_delete': self.auto_delete,
'originator': self.originator,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for RadialDamage.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_action(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_delete(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_originator(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x337f9524: ('damage', _decode_damage),
0x78c507eb: ('radius', _decode_radius),
0x388e5dd3: ('auto_action', _decode_auto_action),
0xdb826cbe: ('auto_delete', _decode_auto_delete),
0x9c951fed: ('originator', _decode_originator),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/RadialDamage.py | 0.569374 | 0.383122 | RadialDamage.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.TriggerInfo import TriggerInfo
@dataclasses.dataclass()
class Trigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
deactivate_on_enter: bool = dataclasses.field(default=False)
deactivate_on_exit: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TRGR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d3F_') # 0x8d33465f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.deactivate_on_enter))
data.write(b'\x1cE9\x86') # 0x1c453986
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.deactivate_on_exit))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
trigger=TriggerInfo.from_json(data['trigger']),
deactivate_on_enter=data['deactivate_on_enter'],
deactivate_on_exit=data['deactivate_on_exit'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger': self.trigger.to_json(),
'deactivate_on_enter': self.deactivate_on_enter,
'deactivate_on_exit': self.deactivate_on_exit,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_trigger(self, asset_manager):
yield from self.trigger.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_trigger, "trigger", "TriggerInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Trigger.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_deactivate_on_enter(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_deactivate_on_exit(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),
0x77a27411: ('trigger', _decode_trigger),
0x8d33465f: ('deactivate_on_enter', _decode_deactivate_on_enter),
0x1c453986: ('deactivate_on_exit', _decode_deactivate_on_exit),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Trigger.py | 0.504883 | 0.306819 | Trigger.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class PlayerController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_0xe71de331: int = dataclasses.field(default=0)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
proxy_type: int = dataclasses.field(default=0)
player_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=1.5))
initial_state: int = dataclasses.field(default=0)
player_visor: int = dataclasses.field(default=0)
unknown_0xf09c2b4b: float = dataclasses.field(default=0.0)
unknown_0x760859e5: float = dataclasses.field(default=0.0)
unknown_0xbd548a40: float = dataclasses.field(default=0.0)
rotation_for_type3: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x70bc90a6: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PLCT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptPlayerProxy.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\x1d\xe31') # 0xe71de331
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe71de331))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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'\xcaV\xa1\x8a') # 0xca56a18a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.proxy_type))
data.write(b'\x1d\x8b\x93?') # 0x1d8b933f
data.write(b'\x00\x0c') # size
self.player_offset.to_stream(data)
data.write(b'\xcbu3\x19') # 0xcb753319
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_state))
data.write(b'\xd9\xc0\x9c\xf7') # 0xd9c09cf7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.player_visor))
data.write(b'\xf0\x9c+K') # 0xf09c2b4b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf09c2b4b))
data.write(b'v\x08Y\xe5') # 0x760859e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x760859e5))
data.write(b'\xbdT\x8a@') # 0xbd548a40
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbd548a40))
data.write(b'\xc0\x12\xf1\x96') # 0xc012f196
data.write(b'\x00\x0c') # size
self.rotation_for_type3.to_stream(data)
data.write(b'p\xbc\x90\xa6') # 0x70bc90a6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0x70bc90a6.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']),
unknown_0xe71de331=data['unknown_0xe71de331'],
model=data['model'],
animation_information=AnimationParameters.from_json(data['animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
proxy_type=data['proxy_type'],
player_offset=Vector.from_json(data['player_offset']),
initial_state=data['initial_state'],
player_visor=data['player_visor'],
unknown_0xf09c2b4b=data['unknown_0xf09c2b4b'],
unknown_0x760859e5=data['unknown_0x760859e5'],
unknown_0xbd548a40=data['unknown_0xbd548a40'],
rotation_for_type3=Vector.from_json(data['rotation_for_type3']),
unknown_0x70bc90a6=data['unknown_0x70bc90a6'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_0xe71de331': self.unknown_0xe71de331,
'model': self.model,
'animation_information': self.animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'proxy_type': self.proxy_type,
'player_offset': self.player_offset.to_json(),
'initial_state': self.initial_state,
'player_visor': self.player_visor,
'unknown_0xf09c2b4b': self.unknown_0xf09c2b4b,
'unknown_0x760859e5': self.unknown_0x760859e5,
'unknown_0xbd548a40': self.unknown_0xbd548a40,
'rotation_for_type3': self.rotation_for_type3.to_json(),
'unknown_0x70bc90a6': self.unknown_0x70bc90a6,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlayerController.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_0xe71de331(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_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_proxy_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_player_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_initial_state(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_player_visor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xf09c2b4b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x760859e5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbd548a40(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_for_type3(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x70bc90a6(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),
0xe71de331: ('unknown_0xe71de331', _decode_unknown_0xe71de331),
0xc27ffa8f: ('model', _decode_model),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xca56a18a: ('proxy_type', _decode_proxy_type),
0x1d8b933f: ('player_offset', _decode_player_offset),
0xcb753319: ('initial_state', _decode_initial_state),
0xd9c09cf7: ('player_visor', _decode_player_visor),
0xf09c2b4b: ('unknown_0xf09c2b4b', _decode_unknown_0xf09c2b4b),
0x760859e5: ('unknown_0x760859e5', _decode_unknown_0x760859e5),
0xbd548a40: ('unknown_0xbd548a40', _decode_unknown_0xbd548a40),
0xc012f196: ('rotation_for_type3', _decode_rotation_for_type3),
0x70bc90a6: ('unknown_0x70bc90a6', _decode_unknown_0x70bc90a6),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PlayerController.py | 0.544196 | 0.232768 | PlayerController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.CameraHintStructA import CameraHintStructA
from retro_data_structures.properties.echoes.archetypes.CameraHintStructB import CameraHintStructB
from retro_data_structures.properties.echoes.archetypes.CameraHintStructC import CameraHintStructC
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.UnknownStruct4 import UnknownStruct4
from retro_data_structures.properties.echoes.archetypes.UnknownStruct5 import UnknownStruct5
from retro_data_structures.properties.echoes.archetypes.UnknownStruct6 import UnknownStruct6
from retro_data_structures.properties.echoes.archetypes.UnknownStruct7 import UnknownStruct7
from retro_data_structures.properties.echoes.archetypes.UnknownStruct8 import UnknownStruct8
from retro_data_structures.properties.echoes.archetypes.UnknownStruct9 import UnknownStruct9
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class CameraHint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
priority: int = dataclasses.field(default=50)
timer: float = dataclasses.field(default=0.0)
unknown_struct4: UnknownStruct4 = dataclasses.field(default_factory=UnknownStruct4)
flags_camera_hint: int = dataclasses.field(default=286)
camera_hint_struct_a_0x456d05c6: CameraHintStructB = dataclasses.field(default_factory=CameraHintStructB)
camera_hint_struct_a_0xf5521ffa: CameraHintStructB = dataclasses.field(default_factory=CameraHintStructB)
camera_hint_struct_a_0x89658a06: CameraHintStructB = dataclasses.field(default_factory=CameraHintStructB)
unknown_struct5: UnknownStruct5 = dataclasses.field(default_factory=UnknownStruct5)
world_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_struct6: UnknownStruct6 = dataclasses.field(default_factory=UnknownStruct6)
camera_hint_struct_b_0x664c450a: CameraHintStructC = dataclasses.field(default_factory=CameraHintStructC)
camera_hint_struct_b_0xc82395fa: CameraHintStructC = dataclasses.field(default_factory=CameraHintStructC)
unknown_struct7: UnknownStruct7 = dataclasses.field(default_factory=UnknownStruct7)
unknown_struct8: UnknownStruct8 = dataclasses.field(default_factory=UnknownStruct8)
unknown_0x2ae08be1: float = dataclasses.field(default=2.0)
unknown_0x4361d075: float = dataclasses.field(default=1.0)
unknown_0xc91ef813: float = dataclasses.field(default=1.0)
camera_hint_struct_a1: CameraHintStructA = dataclasses.field(default_factory=CameraHintStructA)
unknown_struct9: UnknownStruct9 = dataclasses.field(default_factory=UnknownStruct9)
camera_hint_struct_a_0x138729a7: CameraHintStructA = dataclasses.field(default_factory=CameraHintStructA)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CAMH'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'B\x08vP') # 0x42087650
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.priority))
data.write(b'\x87GU.') # 0x8747552e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.timer))
data.write(b'8\x05\x85\xec') # 0x380585ec
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct4.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\xd7 \xa9') # 0x21d720a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_camera_hint))
data.write(b'Em\x05\xc6') # 0x456d05c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_a_0x456d05c6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5R\x1f\xfa') # 0xf5521ffa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_a_0xf5521ffa.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x89e\x8a\x06') # 0x89658a06
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_a_0x89658a06.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x8d\n\x91\x13') # 0x8d0a9113
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct5.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xef\xeb\xe88') # 0xefebe838
data.write(b'\x00\x0c') # size
self.world_offset.to_stream(data)
data.write(b'\xf7\x1c6\xf2') # 0xf71c36f2
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct6.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'fLE\n') # 0x664c450a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_b_0x664c450a.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc8#\x95\xfa') # 0xc82395fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_b_0xc82395fa.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd^\xb0\t') # 0x645eb009
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x80\xcf\xbbT') # 0x80cfbb54
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct8.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'*\xe0\x8b\xe1') # 0x2ae08be1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2ae08be1))
data.write(b'Ca\xd0u') # 0x4361d075
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4361d075))
data.write(b'\xc9\x1e\xf8\x13') # 0xc91ef813
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc91ef813))
data.write(b'\x93N9,') # 0x934e392c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_a1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x9e\x861\xf1') # 0x9e8631f1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x13\x87)\xa7') # 0x138729a7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_hint_struct_a_0x138729a7.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
priority=data['priority'],
timer=data['timer'],
unknown_struct4=UnknownStruct4.from_json(data['unknown_struct4']),
flags_camera_hint=data['flags_camera_hint'],
camera_hint_struct_a_0x456d05c6=CameraHintStructB.from_json(data['camera_hint_struct_a_0x456d05c6']),
camera_hint_struct_a_0xf5521ffa=CameraHintStructB.from_json(data['camera_hint_struct_a_0xf5521ffa']),
camera_hint_struct_a_0x89658a06=CameraHintStructB.from_json(data['camera_hint_struct_a_0x89658a06']),
unknown_struct5=UnknownStruct5.from_json(data['unknown_struct5']),
world_offset=Vector.from_json(data['world_offset']),
unknown_struct6=UnknownStruct6.from_json(data['unknown_struct6']),
camera_hint_struct_b_0x664c450a=CameraHintStructC.from_json(data['camera_hint_struct_b_0x664c450a']),
camera_hint_struct_b_0xc82395fa=CameraHintStructC.from_json(data['camera_hint_struct_b_0xc82395fa']),
unknown_struct7=UnknownStruct7.from_json(data['unknown_struct7']),
unknown_struct8=UnknownStruct8.from_json(data['unknown_struct8']),
unknown_0x2ae08be1=data['unknown_0x2ae08be1'],
unknown_0x4361d075=data['unknown_0x4361d075'],
unknown_0xc91ef813=data['unknown_0xc91ef813'],
camera_hint_struct_a1=CameraHintStructA.from_json(data['camera_hint_struct_a1']),
unknown_struct9=UnknownStruct9.from_json(data['unknown_struct9']),
camera_hint_struct_a_0x138729a7=CameraHintStructA.from_json(data['camera_hint_struct_a_0x138729a7']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'priority': self.priority,
'timer': self.timer,
'unknown_struct4': self.unknown_struct4.to_json(),
'flags_camera_hint': self.flags_camera_hint,
'camera_hint_struct_a_0x456d05c6': self.camera_hint_struct_a_0x456d05c6.to_json(),
'camera_hint_struct_a_0xf5521ffa': self.camera_hint_struct_a_0xf5521ffa.to_json(),
'camera_hint_struct_a_0x89658a06': self.camera_hint_struct_a_0x89658a06.to_json(),
'unknown_struct5': self.unknown_struct5.to_json(),
'world_offset': self.world_offset.to_json(),
'unknown_struct6': self.unknown_struct6.to_json(),
'camera_hint_struct_b_0x664c450a': self.camera_hint_struct_b_0x664c450a.to_json(),
'camera_hint_struct_b_0xc82395fa': self.camera_hint_struct_b_0xc82395fa.to_json(),
'unknown_struct7': self.unknown_struct7.to_json(),
'unknown_struct8': self.unknown_struct8.to_json(),
'unknown_0x2ae08be1': self.unknown_0x2ae08be1,
'unknown_0x4361d075': self.unknown_0x4361d075,
'unknown_0xc91ef813': self.unknown_0xc91ef813,
'camera_hint_struct_a1': self.camera_hint_struct_a1.to_json(),
'unknown_struct9': self.unknown_struct9.to_json(),
'camera_hint_struct_a_0x138729a7': self.camera_hint_struct_a_0x138729a7.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct4(self, asset_manager):
yield from self.unknown_struct4.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_a_0x456d05c6(self, asset_manager):
yield from self.camera_hint_struct_a_0x456d05c6.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_a_0xf5521ffa(self, asset_manager):
yield from self.camera_hint_struct_a_0xf5521ffa.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_a_0x89658a06(self, asset_manager):
yield from self.camera_hint_struct_a_0x89658a06.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct5(self, asset_manager):
yield from self.unknown_struct5.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct6(self, asset_manager):
yield from self.unknown_struct6.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_b_0x664c450a(self, asset_manager):
yield from self.camera_hint_struct_b_0x664c450a.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_b_0xc82395fa(self, asset_manager):
yield from self.camera_hint_struct_b_0xc82395fa.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct7(self, asset_manager):
yield from self.unknown_struct7.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct8(self, asset_manager):
yield from self.unknown_struct8.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_a1(self, asset_manager):
yield from self.camera_hint_struct_a1.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct9(self, asset_manager):
yield from self.unknown_struct9.dependencies_for(asset_manager)
def _dependencies_for_camera_hint_struct_a_0x138729a7(self, asset_manager):
yield from self.camera_hint_struct_a_0x138729a7.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_unknown_struct4, "unknown_struct4", "UnknownStruct4"),
(self._dependencies_for_camera_hint_struct_a_0x456d05c6, "camera_hint_struct_a_0x456d05c6", "CameraHintStructB"),
(self._dependencies_for_camera_hint_struct_a_0xf5521ffa, "camera_hint_struct_a_0xf5521ffa", "CameraHintStructB"),
(self._dependencies_for_camera_hint_struct_a_0x89658a06, "camera_hint_struct_a_0x89658a06", "CameraHintStructB"),
(self._dependencies_for_unknown_struct5, "unknown_struct5", "UnknownStruct5"),
(self._dependencies_for_unknown_struct6, "unknown_struct6", "UnknownStruct6"),
(self._dependencies_for_camera_hint_struct_b_0x664c450a, "camera_hint_struct_b_0x664c450a", "CameraHintStructC"),
(self._dependencies_for_camera_hint_struct_b_0xc82395fa, "camera_hint_struct_b_0xc82395fa", "CameraHintStructC"),
(self._dependencies_for_unknown_struct7, "unknown_struct7", "UnknownStruct7"),
(self._dependencies_for_unknown_struct8, "unknown_struct8", "UnknownStruct8"),
(self._dependencies_for_camera_hint_struct_a1, "camera_hint_struct_a1", "CameraHintStructA"),
(self._dependencies_for_unknown_struct9, "unknown_struct9", "UnknownStruct9"),
(self._dependencies_for_camera_hint_struct_a_0x138729a7, "camera_hint_struct_a_0x138729a7", "CameraHintStructA"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CameraHint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_timer(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_struct4(data: typing.BinaryIO, property_size: int):
return UnknownStruct4.from_stream(data, property_size)
def _decode_flags_camera_hint(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_camera_hint_struct_a_0x456d05c6(data: typing.BinaryIO, property_size: int):
return CameraHintStructB.from_stream(data, property_size)
def _decode_camera_hint_struct_a_0xf5521ffa(data: typing.BinaryIO, property_size: int):
return CameraHintStructB.from_stream(data, property_size)
def _decode_camera_hint_struct_a_0x89658a06(data: typing.BinaryIO, property_size: int):
return CameraHintStructB.from_stream(data, property_size)
def _decode_unknown_struct5(data: typing.BinaryIO, property_size: int):
return UnknownStruct5.from_stream(data, property_size)
def _decode_world_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_struct6(data: typing.BinaryIO, property_size: int):
return UnknownStruct6.from_stream(data, property_size)
def _decode_camera_hint_struct_b_0x664c450a(data: typing.BinaryIO, property_size: int):
return CameraHintStructC.from_stream(data, property_size)
def _decode_camera_hint_struct_b_0xc82395fa(data: typing.BinaryIO, property_size: int):
return CameraHintStructC.from_stream(data, property_size)
def _decode_unknown_struct7(data: typing.BinaryIO, property_size: int):
return UnknownStruct7.from_stream(data, property_size)
def _decode_unknown_struct8(data: typing.BinaryIO, property_size: int):
return UnknownStruct8.from_stream(data, property_size)
def _decode_unknown_0x2ae08be1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4361d075(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc91ef813(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_hint_struct_a1(data: typing.BinaryIO, property_size: int):
return CameraHintStructA.from_stream(data, property_size)
def _decode_unknown_struct9(data: typing.BinaryIO, property_size: int):
return UnknownStruct9.from_stream(data, property_size)
def _decode_camera_hint_struct_a_0x138729a7(data: typing.BinaryIO, property_size: int):
return CameraHintStructA.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x42087650: ('priority', _decode_priority),
0x8747552e: ('timer', _decode_timer),
0x380585ec: ('unknown_struct4', _decode_unknown_struct4),
0x21d720a9: ('flags_camera_hint', _decode_flags_camera_hint),
0x456d05c6: ('camera_hint_struct_a_0x456d05c6', _decode_camera_hint_struct_a_0x456d05c6),
0xf5521ffa: ('camera_hint_struct_a_0xf5521ffa', _decode_camera_hint_struct_a_0xf5521ffa),
0x89658a06: ('camera_hint_struct_a_0x89658a06', _decode_camera_hint_struct_a_0x89658a06),
0x8d0a9113: ('unknown_struct5', _decode_unknown_struct5),
0xefebe838: ('world_offset', _decode_world_offset),
0xf71c36f2: ('unknown_struct6', _decode_unknown_struct6),
0x664c450a: ('camera_hint_struct_b_0x664c450a', _decode_camera_hint_struct_b_0x664c450a),
0xc82395fa: ('camera_hint_struct_b_0xc82395fa', _decode_camera_hint_struct_b_0xc82395fa),
0x645eb009: ('unknown_struct7', _decode_unknown_struct7),
0x80cfbb54: ('unknown_struct8', _decode_unknown_struct8),
0x2ae08be1: ('unknown_0x2ae08be1', _decode_unknown_0x2ae08be1),
0x4361d075: ('unknown_0x4361d075', _decode_unknown_0x4361d075),
0xc91ef813: ('unknown_0xc91ef813', _decode_unknown_0xc91ef813),
0x934e392c: ('camera_hint_struct_a1', _decode_camera_hint_struct_a1),
0x9e8631f1: ('unknown_struct9', _decode_unknown_struct9),
0x138729a7: ('camera_hint_struct_a_0x138729a7', _decode_camera_hint_struct_a_0x138729a7),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CameraHint.py | 0.578329 | 0.21566 | CameraHint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.echoes as enums
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class CameraFilterKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
filter_type: int = dataclasses.field(default=0)
filter_shape: enums.FilterShape = dataclasses.field(default=enums.FilterShape.FullScreen)
filter_stage: int = dataclasses.field(default=0)
which_filter_group: int = dataclasses.field(default=0)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
interpolate_in_time: float = dataclasses.field(default=0.0)
interpolate_out_time: float = dataclasses.field(default=0.0)
texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FILT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'yu\xdb[') # 0x7975db5b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_type))
data.write(b'j>\x9a=') # 0x6a3e9a3d
data.write(b'\x00\x04') # size
self.filter_shape.to_stream(data)
data.write(b'X\xbd\xbd{') # 0x58bdbd7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.filter_stage))
data.write(b'?\xdcK.') # 0x3fdc4b2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_filter_group))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\xab\xd4\x1a6') # 0xabd41a36
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_in_time))
data.write(b'>\xafx\xfe') # 0x3eaf78fe
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.interpolate_out_time))
data.write(b'\xd1\xf6Xr') # 0xd1f65872
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.texture))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
filter_type=data['filter_type'],
filter_shape=enums.FilterShape.from_json(data['filter_shape']),
filter_stage=data['filter_stage'],
which_filter_group=data['which_filter_group'],
color=Color.from_json(data['color']),
interpolate_in_time=data['interpolate_in_time'],
interpolate_out_time=data['interpolate_out_time'],
texture=data['texture'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'filter_type': self.filter_type,
'filter_shape': self.filter_shape.to_json(),
'filter_stage': self.filter_stage,
'which_filter_group': self.which_filter_group,
'color': self.color.to_json(),
'interpolate_in_time': self.interpolate_in_time,
'interpolate_out_time': self.interpolate_out_time,
'texture': self.texture,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.texture)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_texture, "texture", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CameraFilterKeyframe.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_filter_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_filter_shape(data: typing.BinaryIO, property_size: int):
return enums.FilterShape.from_stream(data)
def _decode_filter_stage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_which_filter_group(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_interpolate_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_interpolate_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">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),
0x7975db5b: ('filter_type', _decode_filter_type),
0x6a3e9a3d: ('filter_shape', _decode_filter_shape),
0x58bdbd7b: ('filter_stage', _decode_filter_stage),
0x3fdc4b2e: ('which_filter_group', _decode_which_filter_group),
0x37c7d09d: ('color', _decode_color),
0xabd41a36: ('interpolate_in_time', _decode_interpolate_in_time),
0x3eaf78fe: ('interpolate_out_time', _decode_interpolate_out_time),
0xd1f65872: ('texture', _decode_texture),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CameraFilterKeyframe.py | 0.589716 | 0.296107 | CameraFilterKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Counter(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
initial_count: int = dataclasses.field(default=10)
max_count: int = dataclasses.field(default=10)
auto_reset: bool = dataclasses.field(default=False)
wrap: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CNTR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xfd\x17\x9ao') # 0xfd179a6f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_count))
data.write(b'[\x85\x15\x89') # 0x5b851589
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_count))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'\xf0v\xce\xf5') # 0xf076cef5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.wrap))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
initial_count=data['initial_count'],
max_count=data['max_count'],
auto_reset=data['auto_reset'],
wrap=data['wrap'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'initial_count': self.initial_count,
'max_count': self.max_count,
'auto_reset': self.auto_reset,
'wrap': self.wrap,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Counter.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_initial_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_auto_reset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_wrap(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfd179a6f: ('initial_count', _decode_initial_count),
0x5b851589: ('max_count', _decode_max_count),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0xf076cef5: ('wrap', _decode_wrap),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Counter.py | 0.590661 | 0.33546 | Counter.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class CannonBall(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CANB'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptCannonBall.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6\x8cm\x96') # 0xb68c6d96
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.effect))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
effect=data['effect'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'effect': self.effect,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.effect)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_effect, "effect", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CannonBall.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">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),
0xb68c6d96: ('effect', _decode_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CannonBall.py | 0.592431 | 0.315604 | CannonBall.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.ShockWaveInfo import ShockWaveInfo
@dataclasses.dataclass()
class PuddleSpore(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)
unknown_0x5cdc877d: bool = dataclasses.field(default=True)
charge_time: float = dataclasses.field(default=3.0)
time_open: float = dataclasses.field(default=3.0)
platform_time: float = dataclasses.field(default=7.0)
unknown_0xf1c2d224: float = dataclasses.field(default=30.0)
unknown_0x3c6af2ac: float = dataclasses.field(default=5.0)
hit_detection_angle: float = dataclasses.field(default=30.0)
shock_wave_height: float = dataclasses.field(default=0.0)
sound: int = dataclasses.field(default=0, metadata={'sound': True})
shock_wave_info: ShockWaveInfo = dataclasses.field(default_factory=ShockWaveInfo)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPOR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['PuddleSpore.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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={'detection_range': 35.0, 'detection_height_range': 3.0, 'detection_angle': 180.0, 'damage_wait_time': 0.0, 'collision_radius': 2.5, 'collision_height': 3.0, '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'\\\xdc\x87}') # 0x5cdc877d
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x5cdc877d))
data.write(b'D\xde\x9d\x92') # 0x44de9d92
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.charge_time))
data.write(b'iA_\xae') # 0x69415fae
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time_open))
data.write(b'\xc1 -w') # 0xc1202d77
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.platform_time))
data.write(b'\xf1\xc2\xd2$') # 0xf1c2d224
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf1c2d224))
data.write(b'<j\xf2\xac') # 0x3c6af2ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3c6af2ac))
data.write(b'\xda\xdd\xeb\xe7') # 0xdaddebe7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hit_detection_angle))
data.write(b'B\xad\x13\x92') # 0x42ad1392
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shock_wave_height))
data.write(b'\xfe \xb4\xf5') # 0xfe20b4f5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'\x8fG\x87\xcb') # 0x8f4787cb
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shock_wave_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']),
flavor=data['flavor'],
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_0x5cdc877d=data['unknown_0x5cdc877d'],
charge_time=data['charge_time'],
time_open=data['time_open'],
platform_time=data['platform_time'],
unknown_0xf1c2d224=data['unknown_0xf1c2d224'],
unknown_0x3c6af2ac=data['unknown_0x3c6af2ac'],
hit_detection_angle=data['hit_detection_angle'],
shock_wave_height=data['shock_wave_height'],
sound=data['sound'],
shock_wave_info=ShockWaveInfo.from_json(data['shock_wave_info']),
)
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(),
'unknown_0x5cdc877d': self.unknown_0x5cdc877d,
'charge_time': self.charge_time,
'time_open': self.time_open,
'platform_time': self.platform_time,
'unknown_0xf1c2d224': self.unknown_0xf1c2d224,
'unknown_0x3c6af2ac': self.unknown_0x3c6af2ac,
'hit_detection_angle': self.hit_detection_angle,
'shock_wave_height': self.shock_wave_height,
'sound': self.sound,
'shock_wave_info': self.shock_wave_info.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def _dependencies_for_shock_wave_info(self, asset_manager):
yield from self.shock_wave_info.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_sound, "sound", "int"),
(self._dependencies_for_shock_wave_info, "shock_wave_info", "ShockWaveInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PuddleSpore.{field_name} ({field_type}): {e}"
)
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={'detection_range': 35.0, 'detection_height_range': 3.0, 'detection_angle': 180.0, 'damage_wait_time': 0.0, 'collision_radius': 2.5, 'collision_height': 3.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_0x5cdc877d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_charge_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_time_open(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_platform_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xf1c2d224(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3c6af2ac(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hit_detection_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shock_wave_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_shock_wave_info(data: typing.BinaryIO, property_size: int):
return ShockWaveInfo.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),
0x5cdc877d: ('unknown_0x5cdc877d', _decode_unknown_0x5cdc877d),
0x44de9d92: ('charge_time', _decode_charge_time),
0x69415fae: ('time_open', _decode_time_open),
0xc1202d77: ('platform_time', _decode_platform_time),
0xf1c2d224: ('unknown_0xf1c2d224', _decode_unknown_0xf1c2d224),
0x3c6af2ac: ('unknown_0x3c6af2ac', _decode_unknown_0x3c6af2ac),
0xdaddebe7: ('hit_detection_angle', _decode_hit_detection_angle),
0x42ad1392: ('shock_wave_height', _decode_shock_wave_height),
0xfe20b4f5: ('sound', _decode_sound),
0x8f4787cb: ('shock_wave_info', _decode_shock_wave_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PuddleSpore.py | 0.566019 | 0.307436 | PuddleSpore.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class StoneToad(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'STOD'
@classmethod
def modules(cls) -> typing.List[str]:
return ['StoneToad.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, 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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for StoneToad.{field_name} ({field_type}): {e}"
)
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)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/StoneToad.py | 0.644449 | 0.341061 | StoneToad.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class ShadowProjector(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shadow_scale: float = dataclasses.field(default=1.0)
shadow_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
shadow_height: float = dataclasses.field(default=100.0)
shadow_alpha: float = dataclasses.field(default=0.5)
shadow_fade_time: float = dataclasses.field(default=1.0)
unknown_0xbca8b742: bool = dataclasses.field(default=False)
unknown_0x606e341c: int = dataclasses.field(default=128)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SHDW'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x1d\x01\x1a9') # 0x1d011a39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_scale))
data.write(b'\xf3q\xedY') # 0xf371ed59
data.write(b'\x00\x0c') # size
self.shadow_offset.to_stream(data)
data.write(b'$\xec\x0f\xb0') # 0x24ec0fb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_height))
data.write(b'>,\xd3\x8d') # 0x3e2cd38d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_alpha))
data.write(b'\x8c\xcf6\xc0') # 0x8ccf36c0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shadow_fade_time))
data.write(b'\xbc\xa8\xb7B') # 0xbca8b742
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbca8b742))
data.write(b'`n4\x1c') # 0x606e341c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x606e341c))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shadow_scale=data['shadow_scale'],
shadow_offset=Vector.from_json(data['shadow_offset']),
shadow_height=data['shadow_height'],
shadow_alpha=data['shadow_alpha'],
shadow_fade_time=data['shadow_fade_time'],
unknown_0xbca8b742=data['unknown_0xbca8b742'],
unknown_0x606e341c=data['unknown_0x606e341c'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shadow_scale': self.shadow_scale,
'shadow_offset': self.shadow_offset.to_json(),
'shadow_height': self.shadow_height,
'shadow_alpha': self.shadow_alpha,
'shadow_fade_time': self.shadow_fade_time,
'unknown_0xbca8b742': self.unknown_0xbca8b742,
'unknown_0x606e341c': self.unknown_0x606e341c,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ShadowProjector.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shadow_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_shadow_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shadow_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbca8b742(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x606e341c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x1d011a39: ('shadow_scale', _decode_shadow_scale),
0xf371ed59: ('shadow_offset', _decode_shadow_offset),
0x24ec0fb0: ('shadow_height', _decode_shadow_height),
0x3e2cd38d: ('shadow_alpha', _decode_shadow_alpha),
0x8ccf36c0: ('shadow_fade_time', _decode_shadow_fade_time),
0xbca8b742: ('unknown_0xbca8b742', _decode_unknown_0xbca8b742),
0x606e341c: ('unknown_0x606e341c', _decode_unknown_0x606e341c),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ShadowProjector.py | 0.62681 | 0.343865 | ShadowProjector.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.archetypes.PlatformMotionProperties import PlatformMotionProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Platform(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
collision_box: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
collision_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
collision_model: AssetId = dataclasses.field(metadata={'asset_types': ['DCLN']}, default=default_asset_id)
health: HealthInfo = dataclasses.field(default_factory=HealthInfo)
vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
x_ray_transparency: float = dataclasses.field(default=1.0)
maximum_splashes: int = dataclasses.field(default=200)
splash_generation_rate: int = dataclasses.field(default=20)
render_rain_splashes: bool = dataclasses.field(default=False)
unknown_0xf203bc81: bool = dataclasses.field(default=False)
motion_properties: PlatformMotionProperties = dataclasses.field(default_factory=PlatformMotionProperties)
unknown_0x24fdeea1: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.15000000596046448, z=0.0))
random_animation_offset: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PLAT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x11') # 17 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3D\xc0\xb0') # 0xf344c0b0
data.write(b'\x00\x0c') # size
self.collision_box.to_stream(data)
data.write(b'.hl*') # 0x2e686c2a
data.write(b'\x00\x0c') # size
self.collision_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0f\xc9f\xdc') # 0xfc966dc
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.collision_model))
data.write(b'\xcf\x90\xd1^') # 0xcf90d15e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.health.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'{q\xae\x90') # 0x7b71ae90
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'aP\xd6\x87') # 0x6150d687
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.x_ray_transparency))
data.write(b'\xdc\xd5o\xe8') # 0xdcd56fe8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.maximum_splashes))
data.write(b'h-\xe1\\') # 0x682de15c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.splash_generation_rate))
data.write(b'\xac:\xdd\xa6') # 0xac3adda6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.render_rain_splashes))
data.write(b'\xf2\x03\xbc\x81') # 0xf203bc81
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xf203bc81))
data.write(b'\n\x9d\xbf\x91') # 0xa9dbf91
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$\xfd\xee\xa1') # 0x24fdeea1
data.write(b'\x00\x0c') # size
self.unknown_0x24fdeea1.to_stream(data)
data.write(b'\xbfi\xc0>') # 0xbf69c03e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_animation_offset))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
collision_box=Vector.from_json(data['collision_box']),
collision_offset=Vector.from_json(data['collision_offset']),
model=data['model'],
animation_information=AnimationParameters.from_json(data['animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
collision_model=data['collision_model'],
health=HealthInfo.from_json(data['health']),
vulnerability=DamageVulnerability.from_json(data['vulnerability']),
x_ray_transparency=data['x_ray_transparency'],
maximum_splashes=data['maximum_splashes'],
splash_generation_rate=data['splash_generation_rate'],
render_rain_splashes=data['render_rain_splashes'],
unknown_0xf203bc81=data['unknown_0xf203bc81'],
motion_properties=PlatformMotionProperties.from_json(data['motion_properties']),
unknown_0x24fdeea1=Vector.from_json(data['unknown_0x24fdeea1']),
random_animation_offset=data['random_animation_offset'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'collision_box': self.collision_box.to_json(),
'collision_offset': self.collision_offset.to_json(),
'model': self.model,
'animation_information': self.animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'collision_model': self.collision_model,
'health': self.health.to_json(),
'vulnerability': self.vulnerability.to_json(),
'x_ray_transparency': self.x_ray_transparency,
'maximum_splashes': self.maximum_splashes,
'splash_generation_rate': self.splash_generation_rate,
'render_rain_splashes': self.render_rain_splashes,
'unknown_0xf203bc81': self.unknown_0xf203bc81,
'motion_properties': self.motion_properties.to_json(),
'unknown_0x24fdeea1': self.unknown_0x24fdeea1.to_json(),
'random_animation_offset': self.random_animation_offset,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_collision_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.collision_model)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_motion_properties(self, asset_manager):
yield from self.motion_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_collision_model, "collision_model", "AssetId"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_motion_properties, "motion_properties", "PlatformMotionProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Platform.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_collision_box(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_collision_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_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_collision_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", 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_x_ray_transparency(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_splash_generation_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_render_rain_splashes(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xf203bc81(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_motion_properties(data: typing.BinaryIO, property_size: int):
return PlatformMotionProperties.from_stream(data, property_size)
def _decode_unknown_0x24fdeea1(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_random_animation_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf344c0b0: ('collision_box', _decode_collision_box),
0x2e686c2a: ('collision_offset', _decode_collision_offset),
0xc27ffa8f: ('model', _decode_model),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xfc966dc: ('collision_model', _decode_collision_model),
0xcf90d15e: ('health', _decode_health),
0x7b71ae90: ('vulnerability', _decode_vulnerability),
0x6150d687: ('x_ray_transparency', _decode_x_ray_transparency),
0xdcd56fe8: ('maximum_splashes', _decode_maximum_splashes),
0x682de15c: ('splash_generation_rate', _decode_splash_generation_rate),
0xac3adda6: ('render_rain_splashes', _decode_render_rain_splashes),
0xf203bc81: ('unknown_0xf203bc81', _decode_unknown_0xf203bc81),
0xa9dbf91: ('motion_properties', _decode_motion_properties),
0x24fdeea1: ('unknown_0x24fdeea1', _decode_unknown_0x24fdeea1),
0xbf69c03e: ('random_animation_offset', _decode_random_animation_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Platform.py | 0.61855 | 0.267635 | Platform.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.AimStuff import AimStuff
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Collision import Collision
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.DarkWorld import DarkWorld
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.FirstPersonCamera import FirstPersonCamera
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Frozen import Frozen
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Grapple import Grapple
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.GrappleBeam import GrappleBeam
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Misc import Misc
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Motion import Motion
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Orbit import Orbit
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.ScanVisor import ScanVisor
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.Shield import Shield
from retro_data_structures.properties.echoes.archetypes.TweakPlayer.SuitDamageReduction import SuitDamageReduction
@dataclasses.dataclass()
class TweakPlayer(BaseObjectType):
instance_name: str = dataclasses.field(default='')
dark_world: DarkWorld = dataclasses.field(default_factory=DarkWorld)
grapple_beam: GrappleBeam = dataclasses.field(default_factory=GrappleBeam)
motion: Motion = dataclasses.field(default_factory=Motion)
misc: Misc = dataclasses.field(default_factory=Misc)
aim_stuff: AimStuff = dataclasses.field(default_factory=AimStuff)
orbit: Orbit = dataclasses.field(default_factory=Orbit)
scan_visor: ScanVisor = dataclasses.field(default_factory=ScanVisor)
grapple: Grapple = dataclasses.field(default_factory=Grapple)
collision: Collision = dataclasses.field(default_factory=Collision)
first_person_camera: FirstPersonCamera = dataclasses.field(default_factory=FirstPersonCamera)
shield: Shield = dataclasses.field(default_factory=Shield)
frozen: Frozen = dataclasses.field(default_factory=Frozen)
suit_damage_reduction: SuitDamageReduction = dataclasses.field(default_factory=SuitDamageReduction)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWPL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xdf\xd0\x8e\xba') # 0xdfd08eba
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dark_world.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'E\x17\x1a\x96') # 0x45171a96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grapple_beam.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82\xcfL\xf1') # 0x82cf4cf1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'V\xa7 \xc8') # 0x56a720c8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.misc.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'B\xa1t8') # 0x42a17438
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.aim_stuff.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'$:\xe08') # 0x243ae038
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.orbit.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b' \x12L=') # 0x20124c3d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_visor.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'0A$@') # 0x30412440
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grapple.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc4\xd3*\xe5') # 0xc4d32ae5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.collision.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd6\x15]K') # 0xd6155d4b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.first_person_camera.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xbc\xcav~') # 0xbcca767e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shield.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'M; \xb7') # 0x4d3b20b7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.frozen.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xae\xaf\xf2\x10') # 0xaeaff210
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.suit_damage_reduction.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(
instance_name=data['instance_name'],
dark_world=DarkWorld.from_json(data['dark_world']),
grapple_beam=GrappleBeam.from_json(data['grapple_beam']),
motion=Motion.from_json(data['motion']),
misc=Misc.from_json(data['misc']),
aim_stuff=AimStuff.from_json(data['aim_stuff']),
orbit=Orbit.from_json(data['orbit']),
scan_visor=ScanVisor.from_json(data['scan_visor']),
grapple=Grapple.from_json(data['grapple']),
collision=Collision.from_json(data['collision']),
first_person_camera=FirstPersonCamera.from_json(data['first_person_camera']),
shield=Shield.from_json(data['shield']),
frozen=Frozen.from_json(data['frozen']),
suit_damage_reduction=SuitDamageReduction.from_json(data['suit_damage_reduction']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'dark_world': self.dark_world.to_json(),
'grapple_beam': self.grapple_beam.to_json(),
'motion': self.motion.to_json(),
'misc': self.misc.to_json(),
'aim_stuff': self.aim_stuff.to_json(),
'orbit': self.orbit.to_json(),
'scan_visor': self.scan_visor.to_json(),
'grapple': self.grapple.to_json(),
'collision': self.collision.to_json(),
'first_person_camera': self.first_person_camera.to_json(),
'shield': self.shield.to_json(),
'frozen': self.frozen.to_json(),
'suit_damage_reduction': self.suit_damage_reduction.to_json(),
}
def _dependencies_for_dark_world(self, asset_manager):
yield from self.dark_world.dependencies_for(asset_manager)
def _dependencies_for_grapple_beam(self, asset_manager):
yield from self.grapple_beam.dependencies_for(asset_manager)
def _dependencies_for_motion(self, asset_manager):
yield from self.motion.dependencies_for(asset_manager)
def _dependencies_for_misc(self, asset_manager):
yield from self.misc.dependencies_for(asset_manager)
def _dependencies_for_aim_stuff(self, asset_manager):
yield from self.aim_stuff.dependencies_for(asset_manager)
def _dependencies_for_orbit(self, asset_manager):
yield from self.orbit.dependencies_for(asset_manager)
def _dependencies_for_scan_visor(self, asset_manager):
yield from self.scan_visor.dependencies_for(asset_manager)
def _dependencies_for_grapple(self, asset_manager):
yield from self.grapple.dependencies_for(asset_manager)
def _dependencies_for_collision(self, asset_manager):
yield from self.collision.dependencies_for(asset_manager)
def _dependencies_for_first_person_camera(self, asset_manager):
yield from self.first_person_camera.dependencies_for(asset_manager)
def _dependencies_for_shield(self, asset_manager):
yield from self.shield.dependencies_for(asset_manager)
def _dependencies_for_frozen(self, asset_manager):
yield from self.frozen.dependencies_for(asset_manager)
def _dependencies_for_suit_damage_reduction(self, asset_manager):
yield from self.suit_damage_reduction.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_dark_world, "dark_world", "DarkWorld"),
(self._dependencies_for_grapple_beam, "grapple_beam", "GrappleBeam"),
(self._dependencies_for_motion, "motion", "Motion"),
(self._dependencies_for_misc, "misc", "Misc"),
(self._dependencies_for_aim_stuff, "aim_stuff", "AimStuff"),
(self._dependencies_for_orbit, "orbit", "Orbit"),
(self._dependencies_for_scan_visor, "scan_visor", "ScanVisor"),
(self._dependencies_for_grapple, "grapple", "Grapple"),
(self._dependencies_for_collision, "collision", "Collision"),
(self._dependencies_for_first_person_camera, "first_person_camera", "FirstPersonCamera"),
(self._dependencies_for_shield, "shield", "Shield"),
(self._dependencies_for_frozen, "frozen", "Frozen"),
(self._dependencies_for_suit_damage_reduction, "suit_damage_reduction", "SuitDamageReduction"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakPlayer.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_dark_world(data: typing.BinaryIO, property_size: int):
return DarkWorld.from_stream(data, property_size)
def _decode_grapple_beam(data: typing.BinaryIO, property_size: int):
return GrappleBeam.from_stream(data, property_size)
def _decode_motion(data: typing.BinaryIO, property_size: int):
return Motion.from_stream(data, property_size)
def _decode_misc(data: typing.BinaryIO, property_size: int):
return Misc.from_stream(data, property_size)
def _decode_aim_stuff(data: typing.BinaryIO, property_size: int):
return AimStuff.from_stream(data, property_size)
def _decode_orbit(data: typing.BinaryIO, property_size: int):
return Orbit.from_stream(data, property_size)
def _decode_scan_visor(data: typing.BinaryIO, property_size: int):
return ScanVisor.from_stream(data, property_size)
def _decode_grapple(data: typing.BinaryIO, property_size: int):
return Grapple.from_stream(data, property_size)
def _decode_collision(data: typing.BinaryIO, property_size: int):
return Collision.from_stream(data, property_size)
def _decode_first_person_camera(data: typing.BinaryIO, property_size: int):
return FirstPersonCamera.from_stream(data, property_size)
def _decode_shield(data: typing.BinaryIO, property_size: int):
return Shield.from_stream(data, property_size)
def _decode_frozen(data: typing.BinaryIO, property_size: int):
return Frozen.from_stream(data, property_size)
def _decode_suit_damage_reduction(data: typing.BinaryIO, property_size: int):
return SuitDamageReduction.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0xdfd08eba: ('dark_world', _decode_dark_world),
0x45171a96: ('grapple_beam', _decode_grapple_beam),
0x82cf4cf1: ('motion', _decode_motion),
0x56a720c8: ('misc', _decode_misc),
0x42a17438: ('aim_stuff', _decode_aim_stuff),
0x243ae038: ('orbit', _decode_orbit),
0x20124c3d: ('scan_visor', _decode_scan_visor),
0x30412440: ('grapple', _decode_grapple),
0xc4d32ae5: ('collision', _decode_collision),
0xd6155d4b: ('first_person_camera', _decode_first_person_camera),
0xbcca767e: ('shield', _decode_shield),
0x4d3b20b7: ('frozen', _decode_frozen),
0xaeaff210: ('suit_damage_reduction', _decode_suit_damage_reduction),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakPlayer.py | 0.553023 | 0.256169 | TweakPlayer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Debris(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
impulse: float = dataclasses.field(default=20.0)
impulse_variance: Vector = dataclasses.field(default_factory=lambda: Vector(x=20.0, y=20.0, z=25.0))
fade_out_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=0.0, b=0.0, a=0.0))
mass: float = dataclasses.field(default=12.0)
unknown_0x417f4a91: float = dataclasses.field(default=0.375)
life_time: float = dataclasses.field(default=1.0)
scale_type: int = dataclasses.field(default=0)
random_spin: bool = dataclasses.field(default=True)
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_system_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
is_collider: bool = dataclasses.field(default=True)
unknown_0x4edb1d0e: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DBR1'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0f') # 15 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3\xa7$\xef') # 0xf3a724ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.impulse))
data.write(b'2\xfb\xb5\x12') # 0x32fbb512
data.write(b'\x00\x0c') # size
self.impulse_variance.to_stream(data)
data.write(b'\xd8*\xd5s') # 0xd82ad573
data.write(b'\x00\x10') # size
self.fade_out_color.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'A\x7fJ\x91') # 0x417f4a91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x417f4a91))
data.write(b'\xb0-\xe5U') # 0xb02de555
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.life_time))
data.write(b'q\x82\x9a\xd6') # 0x71829ad6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.scale_type))
data.write(b'\xdd\x17\xb3O') # 0xdd17b34f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.random_spin))
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'm\x1c\xe5%') # 0x6d1ce525
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle))
data.write(b'\x18\xbcA\x9e') # 0x18bc419e
data.write(b'\x00\x0c') # size
self.particle_system_scale.to_stream(data)
data.write(b',{\x18\xdd') # 0x2c7b18dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_collider))
data.write(b'N\xdb\x1d\x0e') # 0x4edb1d0e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4edb1d0e))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
impulse=data['impulse'],
impulse_variance=Vector.from_json(data['impulse_variance']),
fade_out_color=Color.from_json(data['fade_out_color']),
mass=data['mass'],
unknown_0x417f4a91=data['unknown_0x417f4a91'],
life_time=data['life_time'],
scale_type=data['scale_type'],
random_spin=data['random_spin'],
model=data['model'],
actor_information=ActorParameters.from_json(data['actor_information']),
particle=data['particle'],
particle_system_scale=Vector.from_json(data['particle_system_scale']),
is_collider=data['is_collider'],
unknown_0x4edb1d0e=data['unknown_0x4edb1d0e'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'impulse': self.impulse,
'impulse_variance': self.impulse_variance.to_json(),
'fade_out_color': self.fade_out_color.to_json(),
'mass': self.mass,
'unknown_0x417f4a91': self.unknown_0x417f4a91,
'life_time': self.life_time,
'scale_type': self.scale_type,
'random_spin': self.random_spin,
'model': self.model,
'actor_information': self.actor_information.to_json(),
'particle': self.particle,
'particle_system_scale': self.particle_system_scale.to_json(),
'is_collider': self.is_collider,
'unknown_0x4edb1d0e': self.unknown_0x4edb1d0e,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_particle, "particle", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Debris.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_impulse(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_impulse_variance(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_fade_out_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x417f4a91(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scale_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_random_spin(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_particle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_particle_system_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_is_collider(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4edb1d0e(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),
0xf3a724ef: ('impulse', _decode_impulse),
0x32fbb512: ('impulse_variance', _decode_impulse_variance),
0xd82ad573: ('fade_out_color', _decode_fade_out_color),
0x75dbb375: ('mass', _decode_mass),
0x417f4a91: ('unknown_0x417f4a91', _decode_unknown_0x417f4a91),
0xb02de555: ('life_time', _decode_life_time),
0x71829ad6: ('scale_type', _decode_scale_type),
0xdd17b34f: ('random_spin', _decode_random_spin),
0xc27ffa8f: ('model', _decode_model),
0x7e397fed: ('actor_information', _decode_actor_information),
0x6d1ce525: ('particle', _decode_particle),
0x18bc419e: ('particle_system_scale', _decode_particle_system_scale),
0x2c7b18dd: ('is_collider', _decode_is_collider),
0x4edb1d0e: ('unknown_0x4edb1d0e', _decode_unknown_0x4edb1d0e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Debris.py | 0.559049 | 0.29682 | Debris.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation_index: int = dataclasses.field(default=0)
loop: bool = dataclasses.field(default=False)
loop_duration: float = dataclasses.field(default=0.0)
unknown_0x58810503: int = dataclasses.field(default=0)
unknown_0x6d62ef74: int = dataclasses.field(default=0)
playback_rate: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIKF'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x05') # 5 properties
num_properties_written = 5
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1c\xcd\x05\x86') # 0x1ccd0586
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.animation_index))
data.write(b'\xed\xa4\x7f\xf6') # 0xeda47ff6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.loop))
data.write(b'\xce\xe6\x87#') # 0xcee68723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.loop_duration))
data.write(b'X\x81\x05\x03') # 0x58810503
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x58810503))
if self.unknown_0x6d62ef74 != default_override.get('unknown_0x6d62ef74', 0):
num_properties_written += 1
data.write(b'mb\xeft') # 0x6d62ef74
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x6d62ef74))
if self.playback_rate != default_override.get('playback_rate', 1.0):
num_properties_written += 1
data.write(b'o\x8d4\xca') # 0x6f8d34ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.playback_rate))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.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']),
animation_index=data['animation_index'],
loop=data['loop'],
loop_duration=data['loop_duration'],
unknown_0x58810503=data['unknown_0x58810503'],
unknown_0x6d62ef74=data['unknown_0x6d62ef74'],
playback_rate=data['playback_rate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation_index': self.animation_index,
'loop': self.loop,
'loop_duration': self.loop_duration,
'unknown_0x58810503': self.unknown_0x58810503,
'unknown_0x6d62ef74': self.unknown_0x6d62ef74,
'playback_rate': self.playback_rate,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AIKeyframe.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_animation_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_loop(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_loop_duration(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x58810503(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x6d62ef74(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_playback_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x1ccd0586: ('animation_index', _decode_animation_index),
0xeda47ff6: ('loop', _decode_loop),
0xcee68723: ('loop_duration', _decode_loop_duration),
0x58810503: ('unknown_0x58810503', _decode_unknown_0x58810503),
0x6d62ef74: ('unknown_0x6d62ef74', _decode_unknown_0x6d62ef74),
0x6f8d34ca: ('playback_rate', _decode_playback_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AIKeyframe.py | 0.542863 | 0.347814 | AIKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.CameraShakerData import CameraShakerData
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class CameraShaker(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
shaker_data: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CAMS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xadT\x7f\x96') # 0xad547f96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shaker_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
shaker_data=CameraShakerData.from_json(data['shaker_data']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'shaker_data': self.shaker_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_shaker_data(self, asset_manager):
yield from self.shaker_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_shaker_data, "shaker_data", "CameraShakerData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CameraShaker.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_shaker_data(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xad547f96: ('shaker_data', _decode_shaker_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CameraShaker.py | 0.657648 | 0.3617 | CameraShaker.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class Krocuss(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)
waypoint_approach_distance: float = dataclasses.field(default=2.5)
visible_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)
unknown_0xd5c25506: float = dataclasses.field(default=0.4000000059604645)
projectile_bounds_multiplier: float = dataclasses.field(default=1.0)
collision_look_ahead: float = dataclasses.field(default=0.019999999552965164)
anim_speed_scalar: float = dataclasses.field(default=1.0)
initially_paused: bool = dataclasses.field(default=False)
unknown_0xf04cadca: float = dataclasses.field(default=1.0)
unknown_0x497d54e8: float = dataclasses.field(default=1.0)
unknown_0x3371c963: float = dataclasses.field(default=1.0)
unknown_0x22d37771: float = dataclasses.field(default=1.0)
unknown_0xbbebed9e: float = dataclasses.field(default=1.0)
shell_closed_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
wing_light_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=0.0, b=0.0, a=0.0))
dpsc: AssetId = dataclasses.field(metadata={'asset_types': ['DPSC']}, default=default_asset_id)
shell_open_sound: int = dataclasses.field(default=0, metadata={'sound': True})
shell_close_sound: int = dataclasses.field(default=0, metadata={'sound': True})
max_audible_distance: float = dataclasses.field(default=50.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'KROC'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'Krocuss.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'collision_height': 5.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's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\xa7%0\xe8') # 0xa72530e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_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'\xd5\xc2U\x06') # 0xd5c25506
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd5c25506))
data.write(b't.\xab ') # 0x742eab20
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_bounds_multiplier))
data.write(b'\x80\xa8\x19\t') # 0x80a81909
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_look_ahead))
data.write(b'\x85\x90H;') # 0x8590483b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.anim_speed_scalar))
data.write(b'\xc3\xccC\x7f') # 0xc3cc437f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.initially_paused))
data.write(b'\xf0L\xad\xca') # 0xf04cadca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xf04cadca))
data.write(b'I}T\xe8') # 0x497d54e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x497d54e8))
data.write(b'3q\xc9c') # 0x3371c963
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3371c963))
data.write(b'"\xd3wq') # 0x22d37771
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x22d37771))
data.write(b'\xbb\xeb\xed\x9e') # 0xbbebed9e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xbbebed9e))
data.write(b'k\xd1D\xc8') # 0x6bd144c8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shell_closed_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'M bK') # 0x4d20624b
data.write(b'\x00\x10') # size
self.wing_light_color.to_stream(data)
data.write(b'\xc3Va\x14') # 0xc3566114
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.dpsc))
data.write(b'j\x113\x8f') # 0x6a11338f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.shell_open_sound))
data.write(b"\xf6L\xa6'") # 0xf64ca627
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.shell_close_sound))
data.write(b'!NH\xa0') # 0x214e48a0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_audible_distance))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
waypoint_approach_distance=data['waypoint_approach_distance'],
visible_distance=data['visible_distance'],
wall_turn_speed=data['wall_turn_speed'],
floor_turn_speed=data['floor_turn_speed'],
down_turn_speed=data['down_turn_speed'],
unknown_0xd5c25506=data['unknown_0xd5c25506'],
projectile_bounds_multiplier=data['projectile_bounds_multiplier'],
collision_look_ahead=data['collision_look_ahead'],
anim_speed_scalar=data['anim_speed_scalar'],
initially_paused=data['initially_paused'],
unknown_0xf04cadca=data['unknown_0xf04cadca'],
unknown_0x497d54e8=data['unknown_0x497d54e8'],
unknown_0x3371c963=data['unknown_0x3371c963'],
unknown_0x22d37771=data['unknown_0x22d37771'],
unknown_0xbbebed9e=data['unknown_0xbbebed9e'],
shell_closed_vulnerability=DamageVulnerability.from_json(data['shell_closed_vulnerability']),
wing_light_color=Color.from_json(data['wing_light_color']),
dpsc=data['dpsc'],
shell_open_sound=data['shell_open_sound'],
shell_close_sound=data['shell_close_sound'],
max_audible_distance=data['max_audible_distance'],
)
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(),
'waypoint_approach_distance': self.waypoint_approach_distance,
'visible_distance': self.visible_distance,
'wall_turn_speed': self.wall_turn_speed,
'floor_turn_speed': self.floor_turn_speed,
'down_turn_speed': self.down_turn_speed,
'unknown_0xd5c25506': self.unknown_0xd5c25506,
'projectile_bounds_multiplier': self.projectile_bounds_multiplier,
'collision_look_ahead': self.collision_look_ahead,
'anim_speed_scalar': self.anim_speed_scalar,
'initially_paused': self.initially_paused,
'unknown_0xf04cadca': self.unknown_0xf04cadca,
'unknown_0x497d54e8': self.unknown_0x497d54e8,
'unknown_0x3371c963': self.unknown_0x3371c963,
'unknown_0x22d37771': self.unknown_0x22d37771,
'unknown_0xbbebed9e': self.unknown_0xbbebed9e,
'shell_closed_vulnerability': self.shell_closed_vulnerability.to_json(),
'wing_light_color': self.wing_light_color.to_json(),
'dpsc': self.dpsc,
'shell_open_sound': self.shell_open_sound,
'shell_close_sound': self.shell_close_sound,
'max_audible_distance': self.max_audible_distance,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_shell_closed_vulnerability(self, asset_manager):
yield from self.shell_closed_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_dpsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.dpsc)
def _dependencies_for_shell_open_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.shell_open_sound)
def _dependencies_for_shell_close_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.shell_close_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_shell_closed_vulnerability, "shell_closed_vulnerability", "DamageVulnerability"),
(self._dependencies_for_dpsc, "dpsc", "AssetId"),
(self._dependencies_for_shell_open_sound, "shell_open_sound", "int"),
(self._dependencies_for_shell_close_sound, "shell_close_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Krocuss.{field_name} ({field_type}): {e}"
)
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, 'speed': 3.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 3.0, 'collision_radius': 0.20000000298023224, 'collision_height': 5.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_waypoint_approach_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visible_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_unknown_0xd5c25506(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_bounds_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_collision_look_ahead(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_anim_speed_scalar(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_unknown_0xf04cadca(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x497d54e8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3371c963(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x22d37771(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xbbebed9e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shell_closed_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_wing_light_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_dpsc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_shell_open_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_shell_close_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_audible_distance(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),
0xbe73724a: ('flavor', _decode_flavor),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0xa72530e8: ('visible_distance', _decode_visible_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),
0xd5c25506: ('unknown_0xd5c25506', _decode_unknown_0xd5c25506),
0x742eab20: ('projectile_bounds_multiplier', _decode_projectile_bounds_multiplier),
0x80a81909: ('collision_look_ahead', _decode_collision_look_ahead),
0x8590483b: ('anim_speed_scalar', _decode_anim_speed_scalar),
0xc3cc437f: ('initially_paused', _decode_initially_paused),
0xf04cadca: ('unknown_0xf04cadca', _decode_unknown_0xf04cadca),
0x497d54e8: ('unknown_0x497d54e8', _decode_unknown_0x497d54e8),
0x3371c963: ('unknown_0x3371c963', _decode_unknown_0x3371c963),
0x22d37771: ('unknown_0x22d37771', _decode_unknown_0x22d37771),
0xbbebed9e: ('unknown_0xbbebed9e', _decode_unknown_0xbbebed9e),
0x6bd144c8: ('shell_closed_vulnerability', _decode_shell_closed_vulnerability),
0x4d20624b: ('wing_light_color', _decode_wing_light_color),
0xc3566114: ('dpsc', _decode_dpsc),
0x6a11338f: ('shell_open_sound', _decode_shell_open_sound),
0xf64ca627: ('shell_close_sound', _decode_shell_close_sound),
0x214e48a0: ('max_audible_distance', _decode_max_audible_distance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Krocuss.py | 0.621885 | 0.258876 | Krocuss.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
@dataclasses.dataclass()
class TweakCameraBob(BaseObjectType):
instance_name: str = dataclasses.field(default='')
camera_bob_extent_x: float = dataclasses.field(default=0.07000000029802322)
camera_bob_extent_y: float = dataclasses.field(default=0.14000000059604645)
camera_bob_period: float = dataclasses.field(default=0.38999998569488525)
unknown_0xa27bb5a7: float = dataclasses.field(default=0.7699999809265137)
unknown_0xe3580b2b: float = dataclasses.field(default=0.800000011920929)
slow_speed_period_scale: float = dataclasses.field(default=0.30000001192092896)
target_magnitude_tracking_rate: float = dataclasses.field(default=0.10000000149011612)
landing_bob_spring_constant: float = dataclasses.field(default=150.0)
view_wander_radius: float = dataclasses.field(default=0.10000000149011612)
view_wander_speed_min: float = dataclasses.field(default=0.10000000149011612)
view_wander_speed_max: float = dataclasses.field(default=0.4000000059604645)
view_wander_roll_variation: float = dataclasses.field(default=0.30000001192092896)
gun_bob_magnitude: float = dataclasses.field(default=0.2199999988079071)
helmet_bob_magnitude: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWCB'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0f') # 15 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2\xa0\xb6\xf1') # 0xe2a0b6f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_bob_extent_x))
data.write(b')\xfceT') # 0x29fc6554
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_bob_extent_y))
data.write(b'\x14\x9ds9') # 0x149d7339
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.camera_bob_period))
data.write(b'\xa2{\xb5\xa7') # 0xa27bb5a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa27bb5a7))
data.write(b'\xe3X\x0b+') # 0xe3580b2b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe3580b2b))
data.write(b'\xb0]\xad\xe7') # 0xb05dade7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slow_speed_period_scale))
data.write(b'm\xc5\xd4@') # 0x6dc5d440
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_magnitude_tracking_rate))
data.write(b'\xd1e9\xa7') # 0xd16539a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.landing_bob_spring_constant))
data.write(b'\xad\xbb\nB') # 0xadbb0a42
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.view_wander_radius))
data.write(b'\xe7\xf8\xf1\x1b') # 0xe7f8f11b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.view_wander_speed_min))
data.write(b'\x01\x98^\xfa') # 0x1985efa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.view_wander_speed_max))
data.write(b'\xef\x19\xba3') # 0xef19ba33
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.view_wander_roll_variation))
data.write(b'\x7fY\xbe\x96') # 0x7f59be96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gun_bob_magnitude))
data.write(b'8\xa8*\xc1') # 0x38a82ac1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.helmet_bob_magnitude))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
instance_name=data['instance_name'],
camera_bob_extent_x=data['camera_bob_extent_x'],
camera_bob_extent_y=data['camera_bob_extent_y'],
camera_bob_period=data['camera_bob_period'],
unknown_0xa27bb5a7=data['unknown_0xa27bb5a7'],
unknown_0xe3580b2b=data['unknown_0xe3580b2b'],
slow_speed_period_scale=data['slow_speed_period_scale'],
target_magnitude_tracking_rate=data['target_magnitude_tracking_rate'],
landing_bob_spring_constant=data['landing_bob_spring_constant'],
view_wander_radius=data['view_wander_radius'],
view_wander_speed_min=data['view_wander_speed_min'],
view_wander_speed_max=data['view_wander_speed_max'],
view_wander_roll_variation=data['view_wander_roll_variation'],
gun_bob_magnitude=data['gun_bob_magnitude'],
helmet_bob_magnitude=data['helmet_bob_magnitude'],
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'camera_bob_extent_x': self.camera_bob_extent_x,
'camera_bob_extent_y': self.camera_bob_extent_y,
'camera_bob_period': self.camera_bob_period,
'unknown_0xa27bb5a7': self.unknown_0xa27bb5a7,
'unknown_0xe3580b2b': self.unknown_0xe3580b2b,
'slow_speed_period_scale': self.slow_speed_period_scale,
'target_magnitude_tracking_rate': self.target_magnitude_tracking_rate,
'landing_bob_spring_constant': self.landing_bob_spring_constant,
'view_wander_radius': self.view_wander_radius,
'view_wander_speed_min': self.view_wander_speed_min,
'view_wander_speed_max': self.view_wander_speed_max,
'view_wander_roll_variation': self.view_wander_roll_variation,
'gun_bob_magnitude': self.gun_bob_magnitude,
'helmet_bob_magnitude': self.helmet_bob_magnitude,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_camera_bob_extent_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_bob_extent_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_camera_bob_period(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa27bb5a7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe3580b2b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slow_speed_period_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_magnitude_tracking_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_landing_bob_spring_constant(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_view_wander_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_view_wander_speed_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_view_wander_speed_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_view_wander_roll_variation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_gun_bob_magnitude(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_helmet_bob_magnitude(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]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0xe2a0b6f1: ('camera_bob_extent_x', _decode_camera_bob_extent_x),
0x29fc6554: ('camera_bob_extent_y', _decode_camera_bob_extent_y),
0x149d7339: ('camera_bob_period', _decode_camera_bob_period),
0xa27bb5a7: ('unknown_0xa27bb5a7', _decode_unknown_0xa27bb5a7),
0xe3580b2b: ('unknown_0xe3580b2b', _decode_unknown_0xe3580b2b),
0xb05dade7: ('slow_speed_period_scale', _decode_slow_speed_period_scale),
0x6dc5d440: ('target_magnitude_tracking_rate', _decode_target_magnitude_tracking_rate),
0xd16539a7: ('landing_bob_spring_constant', _decode_landing_bob_spring_constant),
0xadbb0a42: ('view_wander_radius', _decode_view_wander_radius),
0xe7f8f11b: ('view_wander_speed_min', _decode_view_wander_speed_min),
0x1985efa: ('view_wander_speed_max', _decode_view_wander_speed_max),
0xef19ba33: ('view_wander_roll_variation', _decode_view_wander_roll_variation),
0x7f59be96: ('gun_bob_magnitude', _decode_gun_bob_magnitude),
0x38a82ac1: ('helmet_bob_magnitude', _decode_helmet_bob_magnitude),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakCameraBob.py | 0.557725 | 0.346707 | TweakCameraBob.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.EmperorIngStage2TentacleData import EmperorIngStage2TentacleData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class EmperorIngStage2Tentacle(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
data: EmperorIngStage2TentacleData = dataclasses.field(default_factory=EmperorIngStage2TentacleData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'EM2T'
@classmethod
def modules(cls) -> typing.List[str]:
return ['EmperorIngStage2Tentacle.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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': 2})
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'Q\x05\xfa-') # 0x5105fa2d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
data=EmperorIngStage2TentacleData.from_json(data['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(),
'data': self.data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_data(self, asset_manager):
yield from self.data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_data, "data", "EmperorIngStage2TentacleData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for EmperorIngStage2Tentacle.{field_name} ({field_type}): {e}"
)
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': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_data(data: typing.BinaryIO, property_size: int):
return EmperorIngStage2TentacleData.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),
0x5105fa2d: ('data', _decode_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/EmperorIngStage2Tentacle.py | 0.594316 | 0.344733 | EmperorIngStage2Tentacle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class FrontEndDataNetwork(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
is_root: bool = dataclasses.field(default=False)
unknown_0x77f59f4a: bool = dataclasses.field(default=False)
unknown_0x29c0cb7f: bool = dataclasses.field(default=True)
can_be_selected: bool = dataclasses.field(default=True)
is_proxy: bool = dataclasses.field(default=False)
is_locked: bool = dataclasses.field(default=False)
unknown_0x8b8fa0fe: bool = dataclasses.field(default=True)
unknown_0xd0f2d612: bool = dataclasses.field(default=False)
connection_radius: float = dataclasses.field(default=8.0)
hot_dot_texture: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
txtr_0x547fffc3: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
txtr_0xcdaaba00: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
selected_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
unselected_min_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.49803900718688965, g=0.49803900718688965, b=0.49803900718688965, a=0.749019980430603))
unselected_max_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.800000011920929, g=0.800000011920929, b=0.800000011920929, a=0.0))
disabled_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.24705900251865387, g=0.24705900251865387, b=0.24705900251865387, a=0.0))
rotation_sound: int = dataclasses.field(default=0, metadata={'sound': True})
transition_shrink_spline: Spline = dataclasses.field(default_factory=Spline)
transition_shrink_time: float = dataclasses.field(default=0.75)
transition_move_spline: Spline = dataclasses.field(default_factory=Spline)
transition_move_time: float = dataclasses.field(default=0.75)
transition_expand_spline: Spline = dataclasses.field(default_factory=Spline)
transition_expand_time: float = dataclasses.field(default=0.75)
transition_move_in_spline: Spline = dataclasses.field(default_factory=Spline)
transition_move_in_time: float = dataclasses.field(default=0.75)
rotation_sound_volume: int = dataclasses.field(default=127)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FNWK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptFrontEndDataNetwork.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1b') # 27 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\\<\x9eJ') # 0x5c3c9e4a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_root))
data.write(b'w\xf5\x9fJ') # 0x77f59f4a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x77f59f4a))
data.write(b')\xc0\xcb\x7f') # 0x29c0cb7f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x29c0cb7f))
data.write(b'\x02\xe7L\xba') # 0x2e74cba
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_selected))
data.write(b'\xa2\xacX\xe9') # 0xa2ac58e9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_proxy))
data.write(b'\xde\xe70\xf5') # 0xdee730f5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_locked))
data.write(b'\x8b\x8f\xa0\xfe') # 0x8b8fa0fe
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x8b8fa0fe))
data.write(b'\xd0\xf2\xd6\x12') # 0xd0f2d612
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xd0f2d612))
data.write(b'^\xbc\x97\xfd') # 0x5ebc97fd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.connection_radius))
data.write(b">W'\xaa") # 0x3e5727aa
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.hot_dot_texture))
data.write(b'T\x7f\xff\xc3') # 0x547fffc3
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.txtr_0x547fffc3))
data.write(b'\xcd\xaa\xba\x00') # 0xcdaaba00
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.txtr_0xcdaaba00))
data.write(b'\x7fb\xda[') # 0x7f62da5b
data.write(b'\x00\x10') # size
self.selected_color.to_stream(data)
data.write(b'\xed(l\xe4') # 0xed286ce4
data.write(b'\x00\x10') # size
self.unselected_min_color.to_stream(data)
data.write(b'\xadg\x14\x92') # 0xad671492
data.write(b'\x00\x10') # size
self.unselected_max_color.to_stream(data)
data.write(b'\xb4MLp') # 0xb44d4c70
data.write(b'\x00\x10') # size
self.disabled_color.to_stream(data)
data.write(b'-#r\x0f') # 0x2d23720f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.rotation_sound))
data.write(b'\xecE\x87\x9e') # 0xec45879e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.transition_shrink_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfa w]') # 0xfa20775d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.transition_shrink_time))
data.write(b'^05J') # 0x5e30354a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.transition_move_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'<\x1f\xa2\xca') # 0x3c1fa2ca
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.transition_move_time))
data.write(b'\xb4\x92\xc2\xaf') # 0xb492c2af
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.transition_expand_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'mQ\x98\xb4') # 0x6d5198b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.transition_expand_time))
data.write(b'\xdf\x1b1,') # 0xdf1b312c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.transition_move_in_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xba\xc1,\xa0') # 0xbac12ca0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.transition_move_in_time))
data.write(b'M\xa9\r6') # 0x4da90d36
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.rotation_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']),
is_root=data['is_root'],
unknown_0x77f59f4a=data['unknown_0x77f59f4a'],
unknown_0x29c0cb7f=data['unknown_0x29c0cb7f'],
can_be_selected=data['can_be_selected'],
is_proxy=data['is_proxy'],
is_locked=data['is_locked'],
unknown_0x8b8fa0fe=data['unknown_0x8b8fa0fe'],
unknown_0xd0f2d612=data['unknown_0xd0f2d612'],
connection_radius=data['connection_radius'],
hot_dot_texture=data['hot_dot_texture'],
txtr_0x547fffc3=data['txtr_0x547fffc3'],
txtr_0xcdaaba00=data['txtr_0xcdaaba00'],
selected_color=Color.from_json(data['selected_color']),
unselected_min_color=Color.from_json(data['unselected_min_color']),
unselected_max_color=Color.from_json(data['unselected_max_color']),
disabled_color=Color.from_json(data['disabled_color']),
rotation_sound=data['rotation_sound'],
transition_shrink_spline=Spline.from_json(data['transition_shrink_spline']),
transition_shrink_time=data['transition_shrink_time'],
transition_move_spline=Spline.from_json(data['transition_move_spline']),
transition_move_time=data['transition_move_time'],
transition_expand_spline=Spline.from_json(data['transition_expand_spline']),
transition_expand_time=data['transition_expand_time'],
transition_move_in_spline=Spline.from_json(data['transition_move_in_spline']),
transition_move_in_time=data['transition_move_in_time'],
rotation_sound_volume=data['rotation_sound_volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'is_root': self.is_root,
'unknown_0x77f59f4a': self.unknown_0x77f59f4a,
'unknown_0x29c0cb7f': self.unknown_0x29c0cb7f,
'can_be_selected': self.can_be_selected,
'is_proxy': self.is_proxy,
'is_locked': self.is_locked,
'unknown_0x8b8fa0fe': self.unknown_0x8b8fa0fe,
'unknown_0xd0f2d612': self.unknown_0xd0f2d612,
'connection_radius': self.connection_radius,
'hot_dot_texture': self.hot_dot_texture,
'txtr_0x547fffc3': self.txtr_0x547fffc3,
'txtr_0xcdaaba00': self.txtr_0xcdaaba00,
'selected_color': self.selected_color.to_json(),
'unselected_min_color': self.unselected_min_color.to_json(),
'unselected_max_color': self.unselected_max_color.to_json(),
'disabled_color': self.disabled_color.to_json(),
'rotation_sound': self.rotation_sound,
'transition_shrink_spline': self.transition_shrink_spline.to_json(),
'transition_shrink_time': self.transition_shrink_time,
'transition_move_spline': self.transition_move_spline.to_json(),
'transition_move_time': self.transition_move_time,
'transition_expand_spline': self.transition_expand_spline.to_json(),
'transition_expand_time': self.transition_expand_time,
'transition_move_in_spline': self.transition_move_in_spline.to_json(),
'transition_move_in_time': self.transition_move_in_time,
'rotation_sound_volume': self.rotation_sound_volume,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_hot_dot_texture(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.hot_dot_texture)
def _dependencies_for_txtr_0x547fffc3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.txtr_0x547fffc3)
def _dependencies_for_txtr_0xcdaaba00(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.txtr_0xcdaaba00)
def _dependencies_for_rotation_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.rotation_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_hot_dot_texture, "hot_dot_texture", "AssetId"),
(self._dependencies_for_txtr_0x547fffc3, "txtr_0x547fffc3", "AssetId"),
(self._dependencies_for_txtr_0xcdaaba00, "txtr_0xcdaaba00", "AssetId"),
(self._dependencies_for_rotation_sound, "rotation_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FrontEndDataNetwork.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_is_root(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x77f59f4a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x29c0cb7f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_can_be_selected(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_proxy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_locked(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x8b8fa0fe(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xd0f2d612(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_connection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hot_dot_texture(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_txtr_0x547fffc3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_txtr_0xcdaaba00(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_selected_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unselected_min_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unselected_max_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_disabled_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_rotation_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_transition_shrink_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_transition_shrink_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_transition_move_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_transition_move_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_transition_expand_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_transition_expand_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_transition_move_in_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_transition_move_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotation_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),
0x5c3c9e4a: ('is_root', _decode_is_root),
0x77f59f4a: ('unknown_0x77f59f4a', _decode_unknown_0x77f59f4a),
0x29c0cb7f: ('unknown_0x29c0cb7f', _decode_unknown_0x29c0cb7f),
0x2e74cba: ('can_be_selected', _decode_can_be_selected),
0xa2ac58e9: ('is_proxy', _decode_is_proxy),
0xdee730f5: ('is_locked', _decode_is_locked),
0x8b8fa0fe: ('unknown_0x8b8fa0fe', _decode_unknown_0x8b8fa0fe),
0xd0f2d612: ('unknown_0xd0f2d612', _decode_unknown_0xd0f2d612),
0x5ebc97fd: ('connection_radius', _decode_connection_radius),
0x3e5727aa: ('hot_dot_texture', _decode_hot_dot_texture),
0x547fffc3: ('txtr_0x547fffc3', _decode_txtr_0x547fffc3),
0xcdaaba00: ('txtr_0xcdaaba00', _decode_txtr_0xcdaaba00),
0x7f62da5b: ('selected_color', _decode_selected_color),
0xed286ce4: ('unselected_min_color', _decode_unselected_min_color),
0xad671492: ('unselected_max_color', _decode_unselected_max_color),
0xb44d4c70: ('disabled_color', _decode_disabled_color),
0x2d23720f: ('rotation_sound', _decode_rotation_sound),
0xec45879e: ('transition_shrink_spline', _decode_transition_shrink_spline),
0xfa20775d: ('transition_shrink_time', _decode_transition_shrink_time),
0x5e30354a: ('transition_move_spline', _decode_transition_move_spline),
0x3c1fa2ca: ('transition_move_time', _decode_transition_move_time),
0xb492c2af: ('transition_expand_spline', _decode_transition_expand_spline),
0x6d5198b4: ('transition_expand_time', _decode_transition_expand_time),
0xdf1b312c: ('transition_move_in_spline', _decode_transition_move_in_spline),
0xbac12ca0: ('transition_move_in_time', _decode_transition_move_in_time),
0x4da90d36: ('rotation_sound_volume', _decode_rotation_sound_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/FrontEndDataNetwork.py | 0.591133 | 0.206474 | FrontEndDataNetwork.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class PathMeshCtrl(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
type: int = dataclasses.field(default=0)
initial_count: int = dataclasses.field(default=1)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PMCT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
data.write(b'zn\r\xe9') # 0x7a6e0de9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_count))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
type=data['type'],
initial_count=data['initial_count'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'type': self.type,
'initial_count': self.initial_count,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PathMeshCtrl.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_initial_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf53dcdd6: ('type', _decode_type),
0x7a6e0de9: ('initial_count', _decode_initial_count),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PathMeshCtrl.py | 0.600657 | 0.346403 | PathMeshCtrl.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.RezbitData import RezbitData
@dataclasses.dataclass()
class Rezbit(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
rezbit_data: RezbitData = dataclasses.field(default_factory=RezbitData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'REZB'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Rezbit.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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, 'min_attack_range': 0.0, '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'\x87\x16\xd6V') # 0x8716d656
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.rezbit_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']),
rezbit_data=RezbitData.from_json(data['rezbit_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(),
'rezbit_data': self.rezbit_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_rezbit_data(self, asset_manager):
yield from self.rezbit_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_rezbit_data, "rezbit_data", "RezbitData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Rezbit.{field_name} ({field_type}): {e}"
)
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, 'min_attack_range': 0.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_rezbit_data(data: typing.BinaryIO, property_size: int):
return RezbitData.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),
0x8716d656: ('rezbit_data', _decode_rezbit_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Rezbit.py | 0.652131 | 0.322299 | Rezbit.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.core.Spline import Spline
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class SurfaceCamera(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_surface_camera: int = dataclasses.field(default=2)
surface_type: int = dataclasses.field(default=1)
spline: Spline = dataclasses.field(default_factory=Spline)
player_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
unknown_0x431769c6: bool = dataclasses.field(default=False)
target_spline_type: SplineType = dataclasses.field(default_factory=SplineType)
unknown_0x33b4f106: bool = dataclasses.field(default=False)
target_control_spline: Spline = dataclasses.field(default_factory=Spline)
fov_spline: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SURC'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x1f\xfce\xd8') # 0x1ffc65d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_surface_camera))
data.write(b'\x14\x05\xb5\xe4') # 0x1405b5e4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.surface_type))
data.write(b'\x92-\x15\x1f') # 0x922d151f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1d\x8b\x93?') # 0x1d8b933f
data.write(b'\x00\x0c') # size
self.player_offset.to_stream(data)
data.write(b'3\xe4h[') # 0x33e4685b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\x17i\xc6') # 0x431769c6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x431769c6))
data.write(b'V\x04\xd3\x04') # 0x5604d304
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.target_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'3\xb4\xf1\x06') # 0x33b4f106
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x33b4f106))
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'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)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_surface_camera=data['flags_surface_camera'],
surface_type=data['surface_type'],
spline=Spline.from_json(data['spline']),
player_offset=Vector.from_json(data['player_offset']),
spline_type=SplineType.from_json(data['spline_type']),
unknown_0x431769c6=data['unknown_0x431769c6'],
target_spline_type=SplineType.from_json(data['target_spline_type']),
unknown_0x33b4f106=data['unknown_0x33b4f106'],
target_control_spline=Spline.from_json(data['target_control_spline']),
fov_spline=Spline.from_json(data['fov_spline']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_surface_camera': self.flags_surface_camera,
'surface_type': self.surface_type,
'spline': self.spline.to_json(),
'player_offset': self.player_offset.to_json(),
'spline_type': self.spline_type.to_json(),
'unknown_0x431769c6': self.unknown_0x431769c6,
'target_spline_type': self.target_spline_type.to_json(),
'unknown_0x33b4f106': self.unknown_0x33b4f106,
'target_control_spline': self.target_control_spline.to_json(),
'fov_spline': self.fov_spline.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_spline_type(self, asset_manager):
yield from self.spline_type.dependencies_for(asset_manager)
def _dependencies_for_target_spline_type(self, asset_manager):
yield from self.target_spline_type.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_spline_type, "spline_type", "SplineType"),
(self._dependencies_for_target_spline_type, "target_spline_type", "SplineType"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SurfaceCamera.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_surface_camera(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_surface_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_player_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_unknown_0x431769c6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_target_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_unknown_0x33b4f106(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_target_control_spline(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_fov_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),
0x1ffc65d8: ('flags_surface_camera', _decode_flags_surface_camera),
0x1405b5e4: ('surface_type', _decode_surface_type),
0x922d151f: ('spline', _decode_spline),
0x1d8b933f: ('player_offset', _decode_player_offset),
0x33e4685b: ('spline_type', _decode_spline_type),
0x431769c6: ('unknown_0x431769c6', _decode_unknown_0x431769c6),
0x5604d304: ('target_spline_type', _decode_target_spline_type),
0x33b4f106: ('unknown_0x33b4f106', _decode_unknown_0x33b4f106),
0xc4dfbfa7: ('target_control_spline', _decode_target_control_spline),
0x6868d4b3: ('fov_spline', _decode_fov_spline),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SurfaceCamera.py | 0.534612 | 0.361954 | SurfaceCamera.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.LayerSwitch import LayerSwitch
@dataclasses.dataclass()
class ScriptLayerController(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
layer: LayerSwitch = dataclasses.field(default_factory=LayerSwitch)
is_dynamic: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SLCT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82I\xf6\xc7') # 0x8249f6c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.layer.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\xa7\xd8\xb2') # 0x12a7d8b2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_dynamic))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
layer=LayerSwitch.from_json(data['layer']),
is_dynamic=data['is_dynamic'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'layer': self.layer.to_json(),
'is_dynamic': self.is_dynamic,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_layer(self, asset_manager):
yield from self.layer.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_layer, "layer", "LayerSwitch"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScriptLayerController.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_layer(data: typing.BinaryIO, property_size: int):
return LayerSwitch.from_stream(data, property_size)
def _decode_is_dynamic(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x8249f6c7: ('layer', _decode_layer),
0x12a7d8b2: ('is_dynamic', _decode_is_dynamic),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ScriptLayerController.py | 0.641085 | 0.350255 | ScriptLayerController.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DigitalGuardianHeadData import DigitalGuardianHeadData
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class DigitalGuardianHead(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
digital_guardian_head_data: DigitalGuardianHeadData = dataclasses.field(default_factory=DigitalGuardianHeadData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DGHD'
@classmethod
def modules(cls) -> typing.List[str]:
return ['DigitalGuardian.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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, 'min_attack_range': 0.0, 'creature_size': 2})
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'\x0fMs\xb7') # 0xf4d73b7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.digital_guardian_head_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']),
digital_guardian_head_data=DigitalGuardianHeadData.from_json(data['digital_guardian_head_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(),
'digital_guardian_head_data': self.digital_guardian_head_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_digital_guardian_head_data(self, asset_manager):
yield from self.digital_guardian_head_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_digital_guardian_head_data, "digital_guardian_head_data", "DigitalGuardianHeadData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DigitalGuardianHead.{field_name} ({field_type}): {e}"
)
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, 'min_attack_range': 0.0, 'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_digital_guardian_head_data(data: typing.BinaryIO, property_size: int):
return DigitalGuardianHeadData.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),
0xf4d73b7: ('digital_guardian_head_data', _decode_digital_guardian_head_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DigitalGuardianHead.py | 0.604632 | 0.360855 | DigitalGuardianHead.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class PlayerStateChange(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
item_to_change: int = dataclasses.field(default=0)
capacity_increase: int = dataclasses.field(default=1)
amount: int = dataclasses.field(default=1)
command: int = dataclasses.field(default=0)
command_action: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PSCH'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'J4\x91\xbd') # 0x4a3491bd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.item_to_change))
data.write(b'(\xc7\x1bT') # 0x28c71b54
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.capacity_increase))
data.write(b'\x94\xaf\x14E') # 0x94af1445
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.amount))
data.write(b'\x94\xbaW7') # 0x94ba5737
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.command))
data.write(b'6=\x98\xa4') # 0x363d98a4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.command_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']),
item_to_change=data['item_to_change'],
capacity_increase=data['capacity_increase'],
amount=data['amount'],
command=data['command'],
command_action=data['command_action'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'item_to_change': self.item_to_change,
'capacity_increase': self.capacity_increase,
'amount': self.amount,
'command': self.command,
'command_action': self.command_action,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlayerStateChange.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_item_to_change(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_capacity_increase(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_command(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_command_action(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),
0x4a3491bd: ('item_to_change', _decode_item_to_change),
0x28c71b54: ('capacity_increase', _decode_capacity_increase),
0x94af1445: ('amount', _decode_amount),
0x94ba5737: ('command', _decode_command),
0x363d98a4: ('command_action', _decode_command_action),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PlayerStateChange.py | 0.569853 | 0.29988 | PlayerStateChange.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct43 import UnknownStruct43
@dataclasses.dataclass()
class SplitterCommandModule(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_struct43: UnknownStruct43 = dataclasses.field(default_factory=UnknownStruct43)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPLU'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Splitter.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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': 60.0, 'min_attack_range': 12.0, 'max_attack_range': 37.0, 'creature_size': 2})
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'V\x0c\xf8\x13') # 0x560cf813
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']),
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(),
'unknown_struct43': self.unknown_struct43.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct43(self, asset_manager):
yield from self.unknown_struct43.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_unknown_struct43, "unknown_struct43", "UnknownStruct43"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SplitterCommandModule.{field_name} ({field_type}): {e}"
)
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': 60.0, 'min_attack_range': 12.0, 'max_attack_range': 37.0, 'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
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),
0x560cf813: ('unknown_struct43', _decode_unknown_struct43),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SplitterCommandModule.py | 0.656658 | 0.281415 | SplitterCommandModule.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class SporbProjectile(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
ball_spit_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
ball_escape_particle_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPBP'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Sporb.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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)
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}O\xc2') # 0x677d4fc2
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ball_spit_particle_effect))
data.write(b'\xaa\xff\x18\x84') # 0xaaff1884
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ball_escape_particle_effect))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
ball_spit_particle_effect=data['ball_spit_particle_effect'],
ball_escape_particle_effect=data['ball_escape_particle_effect'],
)
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(),
'ball_spit_particle_effect': self.ball_spit_particle_effect,
'ball_escape_particle_effect': self.ball_escape_particle_effect,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_ball_spit_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ball_spit_particle_effect)
def _dependencies_for_ball_escape_particle_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ball_escape_particle_effect)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_ball_spit_particle_effect, "ball_spit_particle_effect", "AssetId"),
(self._dependencies_for_ball_escape_particle_effect, "ball_escape_particle_effect", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SporbProjectile.{field_name} ({field_type}): {e}"
)
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_ball_spit_particle_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_ball_escape_particle_effect(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x677d4fc2: ('ball_spit_particle_effect', _decode_ball_spit_particle_effect),
0xaaff1884: ('ball_escape_particle_effect', _decode_ball_escape_particle_effect),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SporbProjectile.py | 0.596433 | 0.324262 | SporbProjectile.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Shrieker(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
buried_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
hostile_accumulate_priority: float = dataclasses.field(default=0.10000000149011612)
damage_info: DamageInfo = dataclasses.field(default_factory=DamageInfo)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
combat_visor_max_volume: int = dataclasses.field(default=50)
echo_visor_max_volume: int = dataclasses.field(default=100)
melee_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
melee_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x9b6a4437: float = dataclasses.field(default=1.0)
melee_attack_time_variation: float = dataclasses.field(default=0.10000000149011612)
melee_range: float = dataclasses.field(default=4.0)
hover_height: float = dataclasses.field(default=0.0)
missile_deflection_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=-1.5))
missile_deflection_radius: float = dataclasses.field(default=15.0)
unknown_0xe70ef8a3: float = dataclasses.field(default=1.0)
sound_missile_deflection: int = dataclasses.field(default=0, metadata={'sound': True})
dodge_time: float = dataclasses.field(default=3.0)
dodge_percentage: float = dataclasses.field(default=20.0)
detection_height: float = dataclasses.field(default=5.0)
unknown_0x4753beb1: float = dataclasses.field(default=15.0)
pop_detection_radius: float = dataclasses.field(default=10.0)
morphball_detection_radius: float = dataclasses.field(default=5.0)
visibility_change_time: float = dataclasses.field(default=0.5)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SHRK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Shrieker.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1c') # 28 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'min_attack_range': 4.5, 'max_attack_range': 30.0, 'average_attack_time': 3.0, 'collision_height': 4.0, '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'\xd7s)#') # 0xd7732923
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.buried_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(\x1c\xe5]') # 0x281ce55d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hostile_accumulate_priority))
data.write(b'\\\x07/\xd0') # 0x5c072fd0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 10.0, 'di_radius': 4.5, 'di_knock_back_power': 4.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0fgk\xd9') # 0xf676bd9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'U;\x139') # 0x553b1339
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 5.0, 'di_knock_back_power': 3.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile))
data.write(b'mF\\\xc2') # 0x6d465cc2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.combat_visor_max_volume))
data.write(b'i\xec\x91\x07') # 0x69ec9107
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.echo_visor_max_volume))
data.write(b'\xc9A`4') # 0xc9416034
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.melee_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 10.0, 'di_radius': 4.5, 'di_knock_back_power': 4.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'b8\xb4\xb5') # 0x6238b4b5
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.melee_effect))
data.write(b'\x9bjD7') # 0x9b6a4437
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9b6a4437))
data.write(b'\xbe\x078\xef') # 0xbe0738ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.melee_attack_time_variation))
data.write(b'9\xabb\xfb') # 0x39ab62fb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.melee_range))
data.write(b'\xc7Y\x98\xaa') # 0xc75998aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_height))
data.write(b'z\xb4\xab\x98') # 0x7ab4ab98
data.write(b'\x00\x0c') # size
self.missile_deflection_offset.to_stream(data)
data.write(b'\x88\xfa*\xcf') # 0x88fa2acf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.missile_deflection_radius))
data.write(b'\xe7\x0e\xf8\xa3') # 0xe70ef8a3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe70ef8a3))
data.write(b"\x85'\xb3\x96") # 0x8527b396
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_missile_deflection))
data.write(b'gb[\xef') # 0x67625bef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dodge_time))
data.write(b'\x1a\xafLC') # 0x1aaf4c43
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.dodge_percentage))
data.write(b'\x9b\xb6\xcb\xc7') # 0x9bb6cbc7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_height))
data.write(b'GS\xbe\xb1') # 0x4753beb1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4753beb1))
data.write(b'\xee\x86<\x15') # 0xee863c15
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pop_detection_radius))
data.write(b'\xae!\xd2\x1d') # 0xae21d21d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.morphball_detection_radius))
data.write(b'=h\x9e\xdd') # 0x3d689edd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visibility_change_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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
buried_vulnerability=DamageVulnerability.from_json(data['buried_vulnerability']),
hostile_accumulate_priority=data['hostile_accumulate_priority'],
damage_info=DamageInfo.from_json(data['damage_info']),
part=data['part'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
projectile=data['projectile'],
combat_visor_max_volume=data['combat_visor_max_volume'],
echo_visor_max_volume=data['echo_visor_max_volume'],
melee_damage=DamageInfo.from_json(data['melee_damage']),
melee_effect=data['melee_effect'],
unknown_0x9b6a4437=data['unknown_0x9b6a4437'],
melee_attack_time_variation=data['melee_attack_time_variation'],
melee_range=data['melee_range'],
hover_height=data['hover_height'],
missile_deflection_offset=Vector.from_json(data['missile_deflection_offset']),
missile_deflection_radius=data['missile_deflection_radius'],
unknown_0xe70ef8a3=data['unknown_0xe70ef8a3'],
sound_missile_deflection=data['sound_missile_deflection'],
dodge_time=data['dodge_time'],
dodge_percentage=data['dodge_percentage'],
detection_height=data['detection_height'],
unknown_0x4753beb1=data['unknown_0x4753beb1'],
pop_detection_radius=data['pop_detection_radius'],
morphball_detection_radius=data['morphball_detection_radius'],
visibility_change_time=data['visibility_change_time'],
)
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(),
'buried_vulnerability': self.buried_vulnerability.to_json(),
'hostile_accumulate_priority': self.hostile_accumulate_priority,
'damage_info': self.damage_info.to_json(),
'part': self.part,
'projectile_damage': self.projectile_damage.to_json(),
'projectile': self.projectile,
'combat_visor_max_volume': self.combat_visor_max_volume,
'echo_visor_max_volume': self.echo_visor_max_volume,
'melee_damage': self.melee_damage.to_json(),
'melee_effect': self.melee_effect,
'unknown_0x9b6a4437': self.unknown_0x9b6a4437,
'melee_attack_time_variation': self.melee_attack_time_variation,
'melee_range': self.melee_range,
'hover_height': self.hover_height,
'missile_deflection_offset': self.missile_deflection_offset.to_json(),
'missile_deflection_radius': self.missile_deflection_radius,
'unknown_0xe70ef8a3': self.unknown_0xe70ef8a3,
'sound_missile_deflection': self.sound_missile_deflection,
'dodge_time': self.dodge_time,
'dodge_percentage': self.dodge_percentage,
'detection_height': self.detection_height,
'unknown_0x4753beb1': self.unknown_0x4753beb1,
'pop_detection_radius': self.pop_detection_radius,
'morphball_detection_radius': self.morphball_detection_radius,
'visibility_change_time': self.visibility_change_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_buried_vulnerability(self, asset_manager):
yield from self.buried_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_damage_info(self, asset_manager):
yield from self.damage_info.dependencies_for(asset_manager)
def _dependencies_for_part(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile)
def _dependencies_for_melee_damage(self, asset_manager):
yield from self.melee_damage.dependencies_for(asset_manager)
def _dependencies_for_melee_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.melee_effect)
def _dependencies_for_sound_missile_deflection(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_missile_deflection)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_buried_vulnerability, "buried_vulnerability", "DamageVulnerability"),
(self._dependencies_for_damage_info, "damage_info", "DamageInfo"),
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_melee_damage, "melee_damage", "DamageInfo"),
(self._dependencies_for_melee_effect, "melee_effect", "AssetId"),
(self._dependencies_for_sound_missile_deflection, "sound_missile_deflection", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Shrieker.{field_name} ({field_type}): {e}"
)
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={'min_attack_range': 4.5, 'max_attack_range': 30.0, 'average_attack_time': 3.0, 'collision_height': 4.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_buried_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_hostile_accumulate_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_info(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 10.0, 'di_radius': 4.5, 'di_knock_back_power': 4.0})
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0, 'di_knock_back_power': 3.0})
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_combat_visor_max_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_echo_visor_max_volume(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_melee_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 10.0, 'di_radius': 4.5, 'di_knock_back_power': 4.0})
def _decode_melee_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x9b6a4437(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_melee_attack_time_variation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_melee_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hover_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_missile_deflection_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_missile_deflection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe70ef8a3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_missile_deflection(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_dodge_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_dodge_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4753beb1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pop_detection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_morphball_detection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visibility_change_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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xd7732923: ('buried_vulnerability', _decode_buried_vulnerability),
0x281ce55d: ('hostile_accumulate_priority', _decode_hostile_accumulate_priority),
0x5c072fd0: ('damage_info', _decode_damage_info),
0xf676bd9: ('part', _decode_part),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0xef485db9: ('projectile', _decode_projectile),
0x6d465cc2: ('combat_visor_max_volume', _decode_combat_visor_max_volume),
0x69ec9107: ('echo_visor_max_volume', _decode_echo_visor_max_volume),
0xc9416034: ('melee_damage', _decode_melee_damage),
0x6238b4b5: ('melee_effect', _decode_melee_effect),
0x9b6a4437: ('unknown_0x9b6a4437', _decode_unknown_0x9b6a4437),
0xbe0738ef: ('melee_attack_time_variation', _decode_melee_attack_time_variation),
0x39ab62fb: ('melee_range', _decode_melee_range),
0xc75998aa: ('hover_height', _decode_hover_height),
0x7ab4ab98: ('missile_deflection_offset', _decode_missile_deflection_offset),
0x88fa2acf: ('missile_deflection_radius', _decode_missile_deflection_radius),
0xe70ef8a3: ('unknown_0xe70ef8a3', _decode_unknown_0xe70ef8a3),
0x8527b396: ('sound_missile_deflection', _decode_sound_missile_deflection),
0x67625bef: ('dodge_time', _decode_dodge_time),
0x1aaf4c43: ('dodge_percentage', _decode_dodge_percentage),
0x9bb6cbc7: ('detection_height', _decode_detection_height),
0x4753beb1: ('unknown_0x4753beb1', _decode_unknown_0x4753beb1),
0xee863c15: ('pop_detection_radius', _decode_pop_detection_radius),
0xae21d21d: ('morphball_detection_radius', _decode_morphball_detection_radius),
0x3d689edd: ('visibility_change_time', _decode_visibility_change_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Shrieker.py | 0.601242 | 0.25811 | Shrieker.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.BasicSwarmProperties import BasicSwarmProperties
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class FlyerSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
basic_swarm_properties: BasicSwarmProperties = dataclasses.field(default_factory=BasicSwarmProperties)
unknown_0x4a85a2da: float = dataclasses.field(default=1.0)
unknown_0x10cccd3c: float = dataclasses.field(default=1.0)
unknown_0x1e8e90a4: float = dataclasses.field(default=0.0)
unknown_0x262e586d: float = dataclasses.field(default=0.0)
roll_upright_speed: float = dataclasses.field(default=0.0)
roll_upright_min_angle: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FSWM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SwarmBasics.rel', 'FlyerSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'\xe1\xecsF') # 0xe1ec7346
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.basic_swarm_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'J\x85\xa2\xda') # 0x4a85a2da
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4a85a2da))
data.write(b'\x10\xcc\xcd<') # 0x10cccd3c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x10cccd3c))
data.write(b'\x1e\x8e\x90\xa4') # 0x1e8e90a4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1e8e90a4))
data.write(b'&.Xm') # 0x262e586d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x262e586d))
data.write(b"G\x9aW'") # 0x479a5727
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_upright_speed))
data.write(b'\xd5r\xd1\xda') # 0xd572d1da
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_upright_min_angle))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
actor_information=ActorParameters.from_json(data['actor_information']),
animation_information=AnimationParameters.from_json(data['animation_information']),
active=data['active'],
basic_swarm_properties=BasicSwarmProperties.from_json(data['basic_swarm_properties']),
unknown_0x4a85a2da=data['unknown_0x4a85a2da'],
unknown_0x10cccd3c=data['unknown_0x10cccd3c'],
unknown_0x1e8e90a4=data['unknown_0x1e8e90a4'],
unknown_0x262e586d=data['unknown_0x262e586d'],
roll_upright_speed=data['roll_upright_speed'],
roll_upright_min_angle=data['roll_upright_min_angle'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'animation_information': self.animation_information.to_json(),
'active': self.active,
'basic_swarm_properties': self.basic_swarm_properties.to_json(),
'unknown_0x4a85a2da': self.unknown_0x4a85a2da,
'unknown_0x10cccd3c': self.unknown_0x10cccd3c,
'unknown_0x1e8e90a4': self.unknown_0x1e8e90a4,
'unknown_0x262e586d': self.unknown_0x262e586d,
'roll_upright_speed': self.roll_upright_speed,
'roll_upright_min_angle': self.roll_upright_min_angle,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_basic_swarm_properties(self, asset_manager):
yield from self.basic_swarm_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_basic_swarm_properties, "basic_swarm_properties", "BasicSwarmProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FlyerSwarm.{field_name} ({field_type}): {e}"
)
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_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_basic_swarm_properties(data: typing.BinaryIO, property_size: int):
return BasicSwarmProperties.from_stream(data, property_size)
def _decode_unknown_0x4a85a2da(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x10cccd3c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1e8e90a4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x262e586d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_upright_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_upright_min_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xc6bb2f45: ('active', _decode_active),
0xe1ec7346: ('basic_swarm_properties', _decode_basic_swarm_properties),
0x4a85a2da: ('unknown_0x4a85a2da', _decode_unknown_0x4a85a2da),
0x10cccd3c: ('unknown_0x10cccd3c', _decode_unknown_0x10cccd3c),
0x1e8e90a4: ('unknown_0x1e8e90a4', _decode_unknown_0x1e8e90a4),
0x262e586d: ('unknown_0x262e586d', _decode_unknown_0x262e586d),
0x479a5727: ('roll_upright_speed', _decode_roll_upright_speed),
0xd572d1da: ('roll_upright_min_angle', _decode_roll_upright_min_angle),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/FlyerSwarm.py | 0.603114 | 0.241691 | FlyerSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RsfAudio(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: str = dataclasses.field(default='')
loop_start: int = dataclasses.field(default=0)
loop_end: int = dataclasses.field(default=0)
fade_in_time: float = dataclasses.field(default=0.25)
fade_out_time: float = dataclasses.field(default=0.25)
volume: int = dataclasses.field(default=127)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RSFA'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptRsfAudio.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xfe\x97\xe5\xb3') # 0xfe97e5b3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'.Yf\x12') # 0x2e596612
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.loop_start))
data.write(b'\xd8Im\xea') # 0xd8496dea
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.loop_end))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\x80\xc6l7') # 0x80c66c37
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.volume))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown=data['unknown'],
loop_start=data['loop_start'],
loop_end=data['loop_end'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
volume=data['volume'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown,
'loop_start': self.loop_start,
'loop_end': self.loop_end,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'volume': self.volume,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for RsfAudio.{field_name} ({field_type}): {e}"
)
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 b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_loop_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_loop_end(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_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),
0xfe97e5b3: ('unknown', _decode_unknown),
0x2e596612: ('loop_start', _decode_loop_start),
0xd8496dea: ('loop_end', _decode_loop_end),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0x80c66c37: ('volume', _decode_volume),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/RsfAudio.py | 0.591841 | 0.301034 | RsfAudio.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class SoundModifier(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=5.0)
auto_reset: bool = dataclasses.field(default=False)
auto_start: bool = dataclasses.field(default=False)
volume: Spline = dataclasses.field(default_factory=Spline)
pan: Spline = dataclasses.field(default_factory=Spline)
surround_pan: Spline = dataclasses.field(default_factory=Spline)
pitch: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SNDM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
data.write(b'{\xefE\xca') # 0x7bef45ca
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_reset))
data.write(b'2\x17\xdf\xf8') # 0x3217dff8
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.auto_start))
data.write(b'\xf3\xfb\xe4\x84') # 0xf3fbe484
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.volume.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'(X\xc9\xf0') # 0x2858c9f0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'Q\x13\x19\x8f') # 0x5113198f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.surround_pan.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0er\x7f\xc4') # 0xe727fc4
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.pitch.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
time=data['time'],
auto_reset=data['auto_reset'],
auto_start=data['auto_start'],
volume=Spline.from_json(data['volume']),
pan=Spline.from_json(data['pan']),
surround_pan=Spline.from_json(data['surround_pan']),
pitch=Spline.from_json(data['pitch']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
'auto_reset': self.auto_reset,
'auto_start': self.auto_start,
'volume': self.volume.to_json(),
'pan': self.pan.to_json(),
'surround_pan': self.surround_pan.to_json(),
'pitch': self.pitch.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SoundModifier.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_auto_reset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_auto_start(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_volume(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pan(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_surround_pan(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_pitch(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44335aff: ('time', _decode_time),
0x7bef45ca: ('auto_reset', _decode_auto_reset),
0x3217dff8: ('auto_start', _decode_auto_start),
0xf3fbe484: ('volume', _decode_volume),
0x2858c9f0: ('pan', _decode_pan),
0x5113198f: ('surround_pan', _decode_surround_pan),
0xe727fc4: ('pitch', _decode_pitch),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SoundModifier.py | 0.605916 | 0.363873 | SoundModifier.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Puffer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
hover_speed: float = dataclasses.field(default=3.0)
cloud_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
cloud_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
cloud_steam: AssetId = dataclasses.field(metadata={'asset_types': ['TXTR']}, default=default_asset_id)
cloud_steam_alpha: float = dataclasses.field(default=0.5)
orbit_interpolant_followed: bool = dataclasses.field(default=True)
cloud_in_dark: bool = dataclasses.field(default=False)
cloud_in_echo: bool = dataclasses.field(default=False)
explosion_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
sound_turn: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PUFR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Puffer.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x84^\xf4\x89') # 0x845ef489
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hover_speed))
data.write(b'g\x0b\x9a\x1f') # 0x670b9a1f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.cloud_effect))
data.write(b'\xe8a\x90\x82') # 0xe8619082
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.cloud_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1a\xa4\x18\xf4') # 0x1aa418f4
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.cloud_steam))
data.write(b'\xc9\xa5Ty') # 0xc9a55479
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cloud_steam_alpha))
data.write(b'\x98d\x7f ') # 0x98647f20
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.orbit_interpolant_followed))
data.write(b'\x8a0\x11/') # 0x8a30112f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.cloud_in_dark))
data.write(b'\x86\xc8\x87\xa5') # 0x86c887a5
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.cloud_in_echo))
data.write(b'\xde\xfft\xea') # 0xdeff74ea
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.explosion_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1f\x80\x15M') # 0x1f80154d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_turn))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
hover_speed=data['hover_speed'],
cloud_effect=data['cloud_effect'],
cloud_damage=DamageInfo.from_json(data['cloud_damage']),
cloud_steam=data['cloud_steam'],
cloud_steam_alpha=data['cloud_steam_alpha'],
orbit_interpolant_followed=data['orbit_interpolant_followed'],
cloud_in_dark=data['cloud_in_dark'],
cloud_in_echo=data['cloud_in_echo'],
explosion_damage=DamageInfo.from_json(data['explosion_damage']),
sound_turn=data['sound_turn'],
)
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(),
'hover_speed': self.hover_speed,
'cloud_effect': self.cloud_effect,
'cloud_damage': self.cloud_damage.to_json(),
'cloud_steam': self.cloud_steam,
'cloud_steam_alpha': self.cloud_steam_alpha,
'orbit_interpolant_followed': self.orbit_interpolant_followed,
'cloud_in_dark': self.cloud_in_dark,
'cloud_in_echo': self.cloud_in_echo,
'explosion_damage': self.explosion_damage.to_json(),
'sound_turn': self.sound_turn,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_cloud_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.cloud_effect)
def _dependencies_for_cloud_damage(self, asset_manager):
yield from self.cloud_damage.dependencies_for(asset_manager)
def _dependencies_for_cloud_steam(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.cloud_steam)
def _dependencies_for_explosion_damage(self, asset_manager):
yield from self.explosion_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_turn(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_turn)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_cloud_effect, "cloud_effect", "AssetId"),
(self._dependencies_for_cloud_damage, "cloud_damage", "DamageInfo"),
(self._dependencies_for_cloud_steam, "cloud_steam", "AssetId"),
(self._dependencies_for_explosion_damage, "explosion_damage", "DamageInfo"),
(self._dependencies_for_sound_turn, "sound_turn", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Puffer.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_hover_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_cloud_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_cloud_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_cloud_steam(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_cloud_steam_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_orbit_interpolant_followed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_cloud_in_dark(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_cloud_in_echo(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_explosion_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_sound_turn(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x845ef489: ('hover_speed', _decode_hover_speed),
0x670b9a1f: ('cloud_effect', _decode_cloud_effect),
0xe8619082: ('cloud_damage', _decode_cloud_damage),
0x1aa418f4: ('cloud_steam', _decode_cloud_steam),
0xc9a55479: ('cloud_steam_alpha', _decode_cloud_steam_alpha),
0x98647f20: ('orbit_interpolant_followed', _decode_orbit_interpolant_followed),
0x8a30112f: ('cloud_in_dark', _decode_cloud_in_dark),
0x86c887a5: ('cloud_in_echo', _decode_cloud_in_echo),
0xdeff74ea: ('explosion_damage', _decode_explosion_damage),
0x1f80154d: ('sound_turn', _decode_sound_turn),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Puffer.py | 0.532425 | 0.290345 | Puffer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Generator(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
random_count: int = dataclasses.field(default=1)
unique_locations: bool = dataclasses.field(default=False)
keep_orientation: bool = dataclasses.field(default=False)
use_originator_transform: bool = dataclasses.field(default=False)
offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
random_scale_min: float = dataclasses.field(default=1.0)
random_scale_max: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GENR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'?\xa6qE') # 0x3fa67145
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.random_count))
data.write(b'\x88\x97\x8eI') # 0x88978e49
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unique_locations))
data.write(b'\x1e\xb8\xe2T') # 0x1eb8e254
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.keep_orientation))
data.write(b'\x03Z^\x10') # 0x35a5e10
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.use_originator_transform))
data.write(b'FGpd') # 0x46477064
data.write(b'\x00\x0c') # size
self.offset.to_stream(data)
data.write(b'\xc3\x86\x1bd') # 0xc3861b64
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_scale_min))
data.write(b'%\xe6\xb4\x85') # 0x25e6b485
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.random_scale_max))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
random_count=data['random_count'],
unique_locations=data['unique_locations'],
keep_orientation=data['keep_orientation'],
use_originator_transform=data['use_originator_transform'],
offset=Vector.from_json(data['offset']),
random_scale_min=data['random_scale_min'],
random_scale_max=data['random_scale_max'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'random_count': self.random_count,
'unique_locations': self.unique_locations,
'keep_orientation': self.keep_orientation,
'use_originator_transform': self.use_originator_transform,
'offset': self.offset.to_json(),
'random_scale_min': self.random_scale_min,
'random_scale_max': self.random_scale_max,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Generator.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_random_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unique_locations(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_keep_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_use_originator_transform(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_random_scale_min(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_random_scale_max(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x3fa67145: ('random_count', _decode_random_count),
0x88978e49: ('unique_locations', _decode_unique_locations),
0x1eb8e254: ('keep_orientation', _decode_keep_orientation),
0x35a5e10: ('use_originator_transform', _decode_use_originator_transform),
0x46477064: ('offset', _decode_offset),
0xc3861b64: ('random_scale_min', _decode_random_scale_min),
0x25e6b485: ('random_scale_max', _decode_random_scale_max),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Generator.py | 0.620852 | 0.382891 | Generator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.TriggerInfo import TriggerInfo
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class BallTrigger(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger: TriggerInfo = dataclasses.field(default_factory=TriggerInfo)
attraction_force: float = dataclasses.field(default=20.0)
attraction_angle: float = dataclasses.field(default=60.0)
attraction_distance: float = dataclasses.field(default=20.0)
attraction_direction: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=0.0, z=0.0))
no_ball_movement: bool = dataclasses.field(default=False)
bounds_size_multiplier: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BALT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
num_properties_written = 7
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'w\xa2t\x11') # 0x77a27411
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.trigger.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb6\x1b\x11I') # 0xb61b1149
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attraction_force))
data.write(b'\x81\xafQ\xd5') # 0x81af51d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attraction_angle))
data.write(b'\xbb8\xd0w') # 0xbb38d077
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attraction_distance))
data.write(b'\xeaQ\x1d\x83') # 0xea511d83
data.write(b'\x00\x0c') # size
self.attraction_direction.to_stream(data)
data.write(b'\xb6\x13\xf4\xe4') # 0xb613f4e4
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_ball_movement))
if self.bounds_size_multiplier != default_override.get('bounds_size_multiplier', 1.0):
num_properties_written += 1
data.write(b"'fcj") # 0x2766636a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.bounds_size_multiplier))
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']),
trigger=TriggerInfo.from_json(data['trigger']),
attraction_force=data['attraction_force'],
attraction_angle=data['attraction_angle'],
attraction_distance=data['attraction_distance'],
attraction_direction=Vector.from_json(data['attraction_direction']),
no_ball_movement=data['no_ball_movement'],
bounds_size_multiplier=data['bounds_size_multiplier'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger': self.trigger.to_json(),
'attraction_force': self.attraction_force,
'attraction_angle': self.attraction_angle,
'attraction_distance': self.attraction_distance,
'attraction_direction': self.attraction_direction.to_json(),
'no_ball_movement': self.no_ball_movement,
'bounds_size_multiplier': self.bounds_size_multiplier,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_trigger(self, asset_manager):
yield from self.trigger.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_trigger, "trigger", "TriggerInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for BallTrigger.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger(data: typing.BinaryIO, property_size: int):
return TriggerInfo.from_stream(data, property_size)
def _decode_attraction_force(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attraction_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attraction_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attraction_direction(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_no_ball_movement(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_bounds_size_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x77a27411: ('trigger', _decode_trigger),
0xb61b1149: ('attraction_force', _decode_attraction_force),
0x81af51d5: ('attraction_angle', _decode_attraction_angle),
0xbb38d077: ('attraction_distance', _decode_attraction_distance),
0xea511d83: ('attraction_direction', _decode_attraction_direction),
0xb613f4e4: ('no_ball_movement', _decode_no_ball_movement),
0x2766636a: ('bounds_size_multiplier', _decode_bounds_size_multiplier),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/BallTrigger.py | 0.615435 | 0.302243 | BallTrigger.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.UnknownStruct35 import UnknownStruct35
@dataclasses.dataclass()
class RubiksPuzzle(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown_struct35: UnknownStruct35 = dataclasses.field(default_factory=UnknownStruct35)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RBPZ'
@classmethod
def modules(cls) -> typing.List[str]:
return ['RubiksPuzzle.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x9f\xcdN8') # 0x9fcd4e38
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct35.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_struct35=UnknownStruct35.from_json(data['unknown_struct35']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown_struct35': self.unknown_struct35.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct35(self, asset_manager):
yield from self.unknown_struct35.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_unknown_struct35, "unknown_struct35", "UnknownStruct35"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for RubiksPuzzle.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_unknown_struct35(data: typing.BinaryIO, property_size: int):
return UnknownStruct35.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),
0x9fcd4e38: ('unknown_struct35', _decode_unknown_struct35),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/RubiksPuzzle.py | 0.624752 | 0.325065 | RubiksPuzzle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.CameraShakerData import CameraShakerData
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class WallWalker(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
leg_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
waypoint_approach_distance: float = dataclasses.field(default=2.5)
floor_turn_speed: float = dataclasses.field(default=1080.0)
unknown_0xd5c25506: float = dataclasses.field(default=0.4000000059604645)
visible_distance: float = dataclasses.field(default=40.0)
explode_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
grenade_explosion: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
grenade_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
grenade_trail: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
grenade_mass: float = dataclasses.field(default=4.0)
unknown_0xed086ce0: float = dataclasses.field(default=0.5)
unknown_0x454f16b1: int = dataclasses.field(default=5)
unknown_0x7f1613b7: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x7050d866: int = dataclasses.field(default=0, metadata={'sound': True})
projectile_interval: float = dataclasses.field(default=2.0)
unknown_0x723542bb: float = dataclasses.field(default=5.0)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
camera_shaker_data: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WLWK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'WallWalker.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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'\x9f\x0f\xf8R') # 0x9f0ff852
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.leg_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\x8eO{)') # 0x8e4f7b29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_turn_speed))
data.write(b'\xd5\xc2U\x06') # 0xd5c25506
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd5c25506))
data.write(b'\xa7%0\xe8') # 0xa72530e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_distance))
data.write(b'\xf6 j\x12') # 0xf6206a12
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.explode_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x13\x19\xe0w') # 0x1319e077
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_explosion))
data.write(b'\xd2\x07\xff\x0f') # 0xd207ff0f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_effect))
data.write(b'+1\xc8\x82') # 0x2b31c882
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_trail))
data.write(b'\x9ak\xb4\x7f') # 0x9a6bb47f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_mass))
data.write(b'\xed\x08l\xe0') # 0xed086ce0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xed086ce0))
data.write(b'EO\x16\xb1') # 0x454f16b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x454f16b1))
data.write(b'\x7f\x16\x13\xb7') # 0x7f1613b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7f1613b7))
data.write(b'pP\xd8f') # 0x7050d866
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7050d866))
data.write(b'\xd4\x90<\x98') # 0xd4903c98
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_interval))
data.write(b'r5B\xbb') # 0x723542bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x723542bb))
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", 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'h\xdcM\x11') # 0x68dc4d11
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'"\xbb\xdd\n') # 0x22bbdd0a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_shaker_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
leg_vulnerability=DamageVulnerability.from_json(data['leg_vulnerability']),
waypoint_approach_distance=data['waypoint_approach_distance'],
floor_turn_speed=data['floor_turn_speed'],
unknown_0xd5c25506=data['unknown_0xd5c25506'],
visible_distance=data['visible_distance'],
explode_damage=DamageInfo.from_json(data['explode_damage']),
grenade_explosion=data['grenade_explosion'],
grenade_effect=data['grenade_effect'],
grenade_trail=data['grenade_trail'],
grenade_mass=data['grenade_mass'],
unknown_0xed086ce0=data['unknown_0xed086ce0'],
unknown_0x454f16b1=data['unknown_0x454f16b1'],
unknown_0x7f1613b7=data['unknown_0x7f1613b7'],
unknown_0x7050d866=data['unknown_0x7050d866'],
projectile_interval=data['projectile_interval'],
unknown_0x723542bb=data['unknown_0x723542bb'],
projectile=data['projectile'],
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
part=data['part'],
camera_shaker_data=CameraShakerData.from_json(data['camera_shaker_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(),
'leg_vulnerability': self.leg_vulnerability.to_json(),
'waypoint_approach_distance': self.waypoint_approach_distance,
'floor_turn_speed': self.floor_turn_speed,
'unknown_0xd5c25506': self.unknown_0xd5c25506,
'visible_distance': self.visible_distance,
'explode_damage': self.explode_damage.to_json(),
'grenade_explosion': self.grenade_explosion,
'grenade_effect': self.grenade_effect,
'grenade_trail': self.grenade_trail,
'grenade_mass': self.grenade_mass,
'unknown_0xed086ce0': self.unknown_0xed086ce0,
'unknown_0x454f16b1': self.unknown_0x454f16b1,
'unknown_0x7f1613b7': self.unknown_0x7f1613b7,
'unknown_0x7050d866': self.unknown_0x7050d866,
'projectile_interval': self.projectile_interval,
'unknown_0x723542bb': self.unknown_0x723542bb,
'projectile': self.projectile,
'projectile_damage': self.projectile_damage.to_json(),
'part': self.part,
'camera_shaker_data': self.camera_shaker_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_leg_vulnerability(self, asset_manager):
yield from self.leg_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_explode_damage(self, asset_manager):
yield from self.explode_damage.dependencies_for(asset_manager)
def _dependencies_for_grenade_explosion(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_explosion)
def _dependencies_for_grenade_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_effect)
def _dependencies_for_grenade_trail(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_trail)
def _dependencies_for_unknown_0x7f1613b7(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x7f1613b7)
def _dependencies_for_unknown_0x7050d866(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x7050d866)
def _dependencies_for_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_part(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part)
def _dependencies_for_camera_shaker_data(self, asset_manager):
yield from self.camera_shaker_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_leg_vulnerability, "leg_vulnerability", "DamageVulnerability"),
(self._dependencies_for_explode_damage, "explode_damage", "DamageInfo"),
(self._dependencies_for_grenade_explosion, "grenade_explosion", "AssetId"),
(self._dependencies_for_grenade_effect, "grenade_effect", "AssetId"),
(self._dependencies_for_grenade_trail, "grenade_trail", "AssetId"),
(self._dependencies_for_unknown_0x7f1613b7, "unknown_0x7f1613b7", "int"),
(self._dependencies_for_unknown_0x7050d866, "unknown_0x7050d866", "int"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_camera_shaker_data, "camera_shaker_data", "CameraShakerData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for WallWalker.{field_name} ({field_type}): {e}"
)
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_leg_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_waypoint_approach_distance(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_unknown_0xd5c25506(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_visible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_explode_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_grenade_explosion(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_grenade_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_grenade_trail(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_grenade_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xed086ce0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x454f16b1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7f1613b7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7050d866(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_projectile_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x723542bb(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(">L", data.read(4))[0]
def _decode_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_camera_shaker_data(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x9f0ff852: ('leg_vulnerability', _decode_leg_vulnerability),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0x8e4f7b29: ('floor_turn_speed', _decode_floor_turn_speed),
0xd5c25506: ('unknown_0xd5c25506', _decode_unknown_0xd5c25506),
0xa72530e8: ('visible_distance', _decode_visible_distance),
0xf6206a12: ('explode_damage', _decode_explode_damage),
0x1319e077: ('grenade_explosion', _decode_grenade_explosion),
0xd207ff0f: ('grenade_effect', _decode_grenade_effect),
0x2b31c882: ('grenade_trail', _decode_grenade_trail),
0x9a6bb47f: ('grenade_mass', _decode_grenade_mass),
0xed086ce0: ('unknown_0xed086ce0', _decode_unknown_0xed086ce0),
0x454f16b1: ('unknown_0x454f16b1', _decode_unknown_0x454f16b1),
0x7f1613b7: ('unknown_0x7f1613b7', _decode_unknown_0x7f1613b7),
0x7050d866: ('unknown_0x7050d866', _decode_unknown_0x7050d866),
0xd4903c98: ('projectile_interval', _decode_projectile_interval),
0x723542bb: ('unknown_0x723542bb', _decode_unknown_0x723542bb),
0xef485db9: ('projectile', _decode_projectile),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0x68dc4d11: ('part', _decode_part),
0x22bbdd0a: ('camera_shaker_data', _decode_camera_shaker_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/WallWalker.py | 0.584034 | 0.253977 | WallWalker.py | 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.echoes as enums
from retro_data_structures.properties.echoes.archetypes.ConditionalTest import ConditionalTest
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ConditionalRelay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
trigger_on_first_think: bool = dataclasses.field(default=False)
multiplayer_mask_and_negate: int = dataclasses.field(default=7680)
conditional1: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional2: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional3: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
conditional4: ConditionalTest = dataclasses.field(default_factory=ConditionalTest)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CRLY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x07') # 7 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D\xdb\x8a\xf2') # 0x44db8af2
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.trigger_on_first_think))
data.write(b',\xc5Nw') # 0x2cc54e77
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.multiplayer_mask_and_negate))
data.write(b'\xce\xc1i2') # 0xcec16932
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional1.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe7\t\xdd\xc0') # 0xe709ddc0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional2.to_stream(data, default_override={'boolean': enums.Boolean.Unknown})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'IaLQ') # 0x49614c51
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional3.to_stream(data, default_override={'boolean': enums.Boolean.Unknown})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb4\x98\xb4$') # 0xb498b424
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.conditional4.to_stream(data, default_override={'boolean': enums.Boolean.Unknown})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
trigger_on_first_think=data['trigger_on_first_think'],
multiplayer_mask_and_negate=data['multiplayer_mask_and_negate'],
conditional1=ConditionalTest.from_json(data['conditional1']),
conditional2=ConditionalTest.from_json(data['conditional2']),
conditional3=ConditionalTest.from_json(data['conditional3']),
conditional4=ConditionalTest.from_json(data['conditional4']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'trigger_on_first_think': self.trigger_on_first_think,
'multiplayer_mask_and_negate': self.multiplayer_mask_and_negate,
'conditional1': self.conditional1.to_json(),
'conditional2': self.conditional2.to_json(),
'conditional3': self.conditional3.to_json(),
'conditional4': self.conditional4.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_conditional1(self, asset_manager):
yield from self.conditional1.dependencies_for(asset_manager)
def _dependencies_for_conditional2(self, asset_manager):
yield from self.conditional2.dependencies_for(asset_manager)
def _dependencies_for_conditional3(self, asset_manager):
yield from self.conditional3.dependencies_for(asset_manager)
def _dependencies_for_conditional4(self, asset_manager):
yield from self.conditional4.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_conditional1, "conditional1", "ConditionalTest"),
(self._dependencies_for_conditional2, "conditional2", "ConditionalTest"),
(self._dependencies_for_conditional3, "conditional3", "ConditionalTest"),
(self._dependencies_for_conditional4, "conditional4", "ConditionalTest"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ConditionalRelay.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_trigger_on_first_think(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_multiplayer_mask_and_negate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_conditional1(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size)
def _decode_conditional2(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': enums.Boolean.Unknown})
def _decode_conditional3(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': enums.Boolean.Unknown})
def _decode_conditional4(data: typing.BinaryIO, property_size: int):
return ConditionalTest.from_stream(data, property_size, default_override={'boolean': enums.Boolean.Unknown})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44db8af2: ('trigger_on_first_think', _decode_trigger_on_first_think),
0x2cc54e77: ('multiplayer_mask_and_negate', _decode_multiplayer_mask_and_negate),
0xcec16932: ('conditional1', _decode_conditional1),
0xe709ddc0: ('conditional2', _decode_conditional2),
0x49614c51: ('conditional3', _decode_conditional3),
0xb498b424: ('conditional4', _decode_conditional4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ConditionalRelay.py | 0.605682 | 0.284699 | ConditionalRelay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class FogOverlay(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
full_alpha: float = dataclasses.field(default=1.0)
fade_down_time: float = dataclasses.field(default=1.0)
fade_up_time: float = dataclasses.field(default=1.0)
start_faded_out: bool = dataclasses.field(default=False)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
ambient_radius_x: float = dataclasses.field(default=0.5)
ambient_radius_y: float = dataclasses.field(default=0.20000000298023224)
ambient_speed: float = dataclasses.field(default=0.10000000149011612)
ambient_speed_target: float = dataclasses.field(default=0.10000000149011612)
unknown_0x6a111b96: float = dataclasses.field(default=1.0)
unknown_0xff226ea3: float = dataclasses.field(default=1.0)
unknown_0x2190ab0a: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
unknown_0x9f19f0af: float = dataclasses.field(default=0.10000000149011612)
unknown_0x90c10fe7: float = dataclasses.field(default=1.0)
unknown_0xd8daff1d: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOGO'
@classmethod
def modules(cls) -> typing.List[str]:
return ['FogOverlay.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x10') # 16 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'T{(\xd5') # 0x547b28d5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.full_alpha))
data.write(b'\xf9w\xcb5') # 0xf977cb35
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_down_time))
data.write(b'\r!\xd3H') # 0xd21d348
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_up_time))
data.write(b'\xeb%\n\x0b') # 0xeb250a0b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.start_faded_out))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'\x1b\x90F\xd6') # 0x1b9046d6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_radius_x))
data.write(b'\xd0\xcc\x95s') # 0xd0cc9573
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_radius_y))
data.write(b'\xf7k\xcb\xdd') # 0xf76bcbdd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_speed))
data.write(b',Lg\x85') # 0x2c4c6785
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.ambient_speed_target))
data.write(b'j\x11\x1b\x96') # 0x6a111b96
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6a111b96))
data.write(b'\xff"n\xa3') # 0xff226ea3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xff226ea3))
data.write(b'!\x90\xab\n') # 0x2190ab0a
data.write(b'\x00\x0c') # size
self.unknown_0x2190ab0a.to_stream(data)
data.write(b'\x9f\x19\xf0\xaf') # 0x9f19f0af
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9f19f0af))
data.write(b'\x90\xc1\x0f\xe7') # 0x90c10fe7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x90c10fe7))
data.write(b'\xd8\xda\xff\x1d') # 0xd8daff1d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd8daff1d))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
full_alpha=data['full_alpha'],
fade_down_time=data['fade_down_time'],
fade_up_time=data['fade_up_time'],
start_faded_out=data['start_faded_out'],
color=Color.from_json(data['color']),
ambient_radius_x=data['ambient_radius_x'],
ambient_radius_y=data['ambient_radius_y'],
ambient_speed=data['ambient_speed'],
ambient_speed_target=data['ambient_speed_target'],
unknown_0x6a111b96=data['unknown_0x6a111b96'],
unknown_0xff226ea3=data['unknown_0xff226ea3'],
unknown_0x2190ab0a=Vector.from_json(data['unknown_0x2190ab0a']),
unknown_0x9f19f0af=data['unknown_0x9f19f0af'],
unknown_0x90c10fe7=data['unknown_0x90c10fe7'],
unknown_0xd8daff1d=data['unknown_0xd8daff1d'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'full_alpha': self.full_alpha,
'fade_down_time': self.fade_down_time,
'fade_up_time': self.fade_up_time,
'start_faded_out': self.start_faded_out,
'color': self.color.to_json(),
'ambient_radius_x': self.ambient_radius_x,
'ambient_radius_y': self.ambient_radius_y,
'ambient_speed': self.ambient_speed,
'ambient_speed_target': self.ambient_speed_target,
'unknown_0x6a111b96': self.unknown_0x6a111b96,
'unknown_0xff226ea3': self.unknown_0xff226ea3,
'unknown_0x2190ab0a': self.unknown_0x2190ab0a.to_json(),
'unknown_0x9f19f0af': self.unknown_0x9f19f0af,
'unknown_0x90c10fe7': self.unknown_0x90c10fe7,
'unknown_0xd8daff1d': self.unknown_0xd8daff1d,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FogOverlay.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_full_alpha(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_down_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_up_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_faded_out(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_ambient_radius_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_radius_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_ambient_speed_target(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6a111b96(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xff226ea3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2190ab0a(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x9f19f0af(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x90c10fe7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd8daff1d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x547b28d5: ('full_alpha', _decode_full_alpha),
0xf977cb35: ('fade_down_time', _decode_fade_down_time),
0xd21d348: ('fade_up_time', _decode_fade_up_time),
0xeb250a0b: ('start_faded_out', _decode_start_faded_out),
0x37c7d09d: ('color', _decode_color),
0x1b9046d6: ('ambient_radius_x', _decode_ambient_radius_x),
0xd0cc9573: ('ambient_radius_y', _decode_ambient_radius_y),
0xf76bcbdd: ('ambient_speed', _decode_ambient_speed),
0x2c4c6785: ('ambient_speed_target', _decode_ambient_speed_target),
0x6a111b96: ('unknown_0x6a111b96', _decode_unknown_0x6a111b96),
0xff226ea3: ('unknown_0xff226ea3', _decode_unknown_0xff226ea3),
0x2190ab0a: ('unknown_0x2190ab0a', _decode_unknown_0x2190ab0a),
0x9f19f0af: ('unknown_0x9f19f0af', _decode_unknown_0x9f19f0af),
0x90c10fe7: ('unknown_0x90c10fe7', _decode_unknown_0x90c10fe7),
0xd8daff1d: ('unknown_0xd8daff1d', _decode_unknown_0xd8daff1d),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/FogOverlay.py | 0.571169 | 0.298276 | FogOverlay.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SpiderBallAttractionSurface(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BALS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpiderBallAttractionSurface.{field_name} ({field_type}): {e}"
)
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/echoes/objects/SpiderBallAttractionSurface.py | 0.634656 | 0.360658 | SpiderBallAttractionSurface.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DigitalGuardianData import DigitalGuardianData
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class DigitalGuardian(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
digital_guardian_data: DigitalGuardianData = dataclasses.field(default_factory=DigitalGuardianData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DGRD'
@classmethod
def modules(cls) -> typing.List[str]:
return ['DigitalGuardian.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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, 'min_attack_range': 0.0, 'creature_size': 2})
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'\xc5Y\x18\xcc') # 0xc55918cc
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.digital_guardian_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']),
digital_guardian_data=DigitalGuardianData.from_json(data['digital_guardian_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(),
'digital_guardian_data': self.digital_guardian_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_digital_guardian_data(self, asset_manager):
yield from self.digital_guardian_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_digital_guardian_data, "digital_guardian_data", "DigitalGuardianData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DigitalGuardian.{field_name} ({field_type}): {e}"
)
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, 'min_attack_range': 0.0, 'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_digital_guardian_data(data: typing.BinaryIO, property_size: int):
return DigitalGuardianData.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),
0xc55918cc: ('digital_guardian_data', _decode_digital_guardian_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DigitalGuardian.py | 0.654564 | 0.36311 | DigitalGuardian.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct28 import UnknownStruct28
from retro_data_structures.properties.echoes.archetypes.UnknownStruct29 import UnknownStruct29
@dataclasses.dataclass()
class IngBoostBallGuardian(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_struct28: UnknownStruct28 = dataclasses.field(default_factory=UnknownStruct28)
unknown_struct29: UnknownStruct29 = dataclasses.field(default_factory=UnknownStruct29)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'IBBG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['GeomBlobV2.rel', 'Ing.rel', 'IngBoostBallGuardian.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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={'turn_speed': 360.0, 'min_attack_range': 0.0, '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'"\xe5t\xaa') # 0x22e574aa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct28.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'xem\x1e') # 0x78656d1e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct29.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_struct28=UnknownStruct28.from_json(data['unknown_struct28']),
unknown_struct29=UnknownStruct29.from_json(data['unknown_struct29']),
)
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_struct28': self.unknown_struct28.to_json(),
'unknown_struct29': self.unknown_struct29.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct28(self, asset_manager):
yield from self.unknown_struct28.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct29(self, asset_manager):
yield from self.unknown_struct29.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_unknown_struct28, "unknown_struct28", "UnknownStruct28"),
(self._dependencies_for_unknown_struct29, "unknown_struct29", "UnknownStruct29"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IngBoostBallGuardian.{field_name} ({field_type}): {e}"
)
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, 'min_attack_range': 0.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct28(data: typing.BinaryIO, property_size: int):
return UnknownStruct28.from_stream(data, property_size)
def _decode_unknown_struct29(data: typing.BinaryIO, property_size: int):
return UnknownStruct29.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),
0x22e574aa: ('unknown_struct28', _decode_unknown_struct28),
0x78656d1e: ('unknown_struct29', _decode_unknown_struct29),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/IngBoostBallGuardian.py | 0.600774 | 0.335079 | IngBoostBallGuardian.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.BasicSwarmProperties import BasicSwarmProperties
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlantScarabSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
basic_swarm_properties: BasicSwarmProperties = dataclasses.field(default_factory=BasicSwarmProperties)
unknown_0x7399abbb: int = dataclasses.field(default=0)
unknown_0x734d923b: int = dataclasses.field(default=0)
max_attack_angle: float = dataclasses.field(default=30.0)
into_attack_speed: float = dataclasses.field(default=1.0)
attack_speed: float = dataclasses.field(default=1.0)
grenade_mass: float = dataclasses.field(default=1.0)
grenade_launch_speed: float = dataclasses.field(default=1.0)
unknown_0xed086ce0: float = dataclasses.field(default=0.5)
unknown_0x454f16b1: int = dataclasses.field(default=3)
grenade_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
grenade_explosion_proximity: float = dataclasses.field(default=0.5)
grenade_explosion_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
grenade_trail_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
grenade_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
grenade_bounce_sound: int = dataclasses.field(default=0, metadata={'sound': True})
grenade_bounce_sound_fall_off: float = dataclasses.field(default=0.0)
unknown_0x15e0c159: float = dataclasses.field(default=100.0)
grenade_explosion_sound: int = dataclasses.field(default=0, metadata={'sound': True})
grenade_explosion_sound_fall_off: float = dataclasses.field(default=0.0)
unknown_0xab84892e: float = dataclasses.field(default=100.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PSSM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SwarmBasics.rel', 'PlantScarabSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1a') # 26 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_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'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'\xe1\xecsF') # 0xe1ec7346
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.basic_swarm_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\x99\xab\xbb') # 0x7399abbb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7399abbb))
data.write(b'sM\x92;') # 0x734d923b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x734d923b))
data.write(b'\xf1\x1fs\x84') # 0xf11f7384
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_angle))
data.write(b'\xcav\x1d\xcd') # 0xca761dcd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.into_attack_speed))
data.write(b'l\n+\xc8') # 0x6c0a2bc8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_speed))
data.write(b'\x9ak\xb4\x7f') # 0x9a6bb47f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_mass))
data.write(b'\x16\x96,\x9b') # 0x16962c9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_launch_speed))
data.write(b'\xed\x08l\xe0') # 0xed086ce0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xed086ce0))
data.write(b'EO\x16\xb1') # 0x454f16b1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x454f16b1))
data.write(b'\x14\xd1\xa3\xa8') # 0x14d1a3a8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grenade_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'l|\xa1!') # 0x6c7ca121
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_explosion_proximity))
data.write(b'\xeaP\x0e\x8b') # 0xea500e8b
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_explosion_effect))
data.write(b'@\x99-Q') # 0x40992d51
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'\x11@\xd1\x1d') # 0x1140d11d
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_trail_effect))
data.write(b'\xd2\x07\xff\x0f') # 0xd207ff0f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.grenade_effect))
data.write(b',\x1d\xfa"') # 0x2c1dfa22
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.grenade_bounce_sound))
data.write(b'(^\xfb\xd9') # 0x285efbd9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_bounce_sound_fall_off))
data.write(b'\x15\xe0\xc1Y') # 0x15e0c159
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x15e0c159))
data.write(b'0u,\x95') # 0x30752c95
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.grenade_explosion_sound))
data.write(b'\xbaf\xa1n') # 0xba66a16e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grenade_explosion_sound_fall_off))
data.write(b'\xab\x84\x89.') # 0xab84892e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xab84892e))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
animation_information=AnimationParameters.from_json(data['animation_information']),
active=data['active'],
basic_swarm_properties=BasicSwarmProperties.from_json(data['basic_swarm_properties']),
unknown_0x7399abbb=data['unknown_0x7399abbb'],
unknown_0x734d923b=data['unknown_0x734d923b'],
max_attack_angle=data['max_attack_angle'],
into_attack_speed=data['into_attack_speed'],
attack_speed=data['attack_speed'],
grenade_mass=data['grenade_mass'],
grenade_launch_speed=data['grenade_launch_speed'],
unknown_0xed086ce0=data['unknown_0xed086ce0'],
unknown_0x454f16b1=data['unknown_0x454f16b1'],
grenade_damage=DamageInfo.from_json(data['grenade_damage']),
grenade_explosion_proximity=data['grenade_explosion_proximity'],
grenade_explosion_effect=data['grenade_explosion_effect'],
part=data['part'],
grenade_trail_effect=data['grenade_trail_effect'],
grenade_effect=data['grenade_effect'],
grenade_bounce_sound=data['grenade_bounce_sound'],
grenade_bounce_sound_fall_off=data['grenade_bounce_sound_fall_off'],
unknown_0x15e0c159=data['unknown_0x15e0c159'],
grenade_explosion_sound=data['grenade_explosion_sound'],
grenade_explosion_sound_fall_off=data['grenade_explosion_sound_fall_off'],
unknown_0xab84892e=data['unknown_0xab84892e'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'animation_information': self.animation_information.to_json(),
'active': self.active,
'basic_swarm_properties': self.basic_swarm_properties.to_json(),
'unknown_0x7399abbb': self.unknown_0x7399abbb,
'unknown_0x734d923b': self.unknown_0x734d923b,
'max_attack_angle': self.max_attack_angle,
'into_attack_speed': self.into_attack_speed,
'attack_speed': self.attack_speed,
'grenade_mass': self.grenade_mass,
'grenade_launch_speed': self.grenade_launch_speed,
'unknown_0xed086ce0': self.unknown_0xed086ce0,
'unknown_0x454f16b1': self.unknown_0x454f16b1,
'grenade_damage': self.grenade_damage.to_json(),
'grenade_explosion_proximity': self.grenade_explosion_proximity,
'grenade_explosion_effect': self.grenade_explosion_effect,
'part': self.part,
'grenade_trail_effect': self.grenade_trail_effect,
'grenade_effect': self.grenade_effect,
'grenade_bounce_sound': self.grenade_bounce_sound,
'grenade_bounce_sound_fall_off': self.grenade_bounce_sound_fall_off,
'unknown_0x15e0c159': self.unknown_0x15e0c159,
'grenade_explosion_sound': self.grenade_explosion_sound,
'grenade_explosion_sound_fall_off': self.grenade_explosion_sound_fall_off,
'unknown_0xab84892e': self.unknown_0xab84892e,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_basic_swarm_properties(self, asset_manager):
yield from self.basic_swarm_properties.dependencies_for(asset_manager)
def _dependencies_for_grenade_damage(self, asset_manager):
yield from self.grenade_damage.dependencies_for(asset_manager)
def _dependencies_for_grenade_explosion_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_explosion_effect)
def _dependencies_for_part(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part)
def _dependencies_for_grenade_trail_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_trail_effect)
def _dependencies_for_grenade_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.grenade_effect)
def _dependencies_for_grenade_bounce_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.grenade_bounce_sound)
def _dependencies_for_grenade_explosion_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.grenade_explosion_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_basic_swarm_properties, "basic_swarm_properties", "BasicSwarmProperties"),
(self._dependencies_for_grenade_damage, "grenade_damage", "DamageInfo"),
(self._dependencies_for_grenade_explosion_effect, "grenade_explosion_effect", "AssetId"),
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_grenade_trail_effect, "grenade_trail_effect", "AssetId"),
(self._dependencies_for_grenade_effect, "grenade_effect", "AssetId"),
(self._dependencies_for_grenade_bounce_sound, "grenade_bounce_sound", "int"),
(self._dependencies_for_grenade_explosion_sound, "grenade_explosion_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlantScarabSwarm.{field_name} ({field_type}): {e}"
)
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_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_basic_swarm_properties(data: typing.BinaryIO, property_size: int):
return BasicSwarmProperties.from_stream(data, property_size)
def _decode_unknown_0x7399abbb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x734d923b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_attack_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_into_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_launch_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xed086ce0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x454f16b1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_grenade_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_grenade_explosion_proximity(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_explosion_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_grenade_trail_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_grenade_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_grenade_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_grenade_bounce_sound_fall_off(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x15e0c159(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grenade_explosion_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_grenade_explosion_sound_fall_off(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xab84892e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xc6bb2f45: ('active', _decode_active),
0xe1ec7346: ('basic_swarm_properties', _decode_basic_swarm_properties),
0x7399abbb: ('unknown_0x7399abbb', _decode_unknown_0x7399abbb),
0x734d923b: ('unknown_0x734d923b', _decode_unknown_0x734d923b),
0xf11f7384: ('max_attack_angle', _decode_max_attack_angle),
0xca761dcd: ('into_attack_speed', _decode_into_attack_speed),
0x6c0a2bc8: ('attack_speed', _decode_attack_speed),
0x9a6bb47f: ('grenade_mass', _decode_grenade_mass),
0x16962c9b: ('grenade_launch_speed', _decode_grenade_launch_speed),
0xed086ce0: ('unknown_0xed086ce0', _decode_unknown_0xed086ce0),
0x454f16b1: ('unknown_0x454f16b1', _decode_unknown_0x454f16b1),
0x14d1a3a8: ('grenade_damage', _decode_grenade_damage),
0x6c7ca121: ('grenade_explosion_proximity', _decode_grenade_explosion_proximity),
0xea500e8b: ('grenade_explosion_effect', _decode_grenade_explosion_effect),
0x40992d51: ('part', _decode_part),
0x1140d11d: ('grenade_trail_effect', _decode_grenade_trail_effect),
0xd207ff0f: ('grenade_effect', _decode_grenade_effect),
0x2c1dfa22: ('grenade_bounce_sound', _decode_grenade_bounce_sound),
0x285efbd9: ('grenade_bounce_sound_fall_off', _decode_grenade_bounce_sound_fall_off),
0x15e0c159: ('unknown_0x15e0c159', _decode_unknown_0x15e0c159),
0x30752c95: ('grenade_explosion_sound', _decode_grenade_explosion_sound),
0xba66a16e: ('grenade_explosion_sound_fall_off', _decode_grenade_explosion_sound_fall_off),
0xab84892e: ('unknown_0xab84892e', _decode_unknown_0xab84892e),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PlantScarabSwarm.py | 0.583203 | 0.216105 | PlantScarabSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.GrappleParameters import GrappleParameters
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class Ripper(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)
grapple_info: GrappleParameters = dataclasses.field(default_factory=GrappleParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RIPR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Ripper.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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)
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'j(r\xd8') # 0x6a2872d8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.grapple_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']),
flavor=data['flavor'],
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
grapple_info=GrappleParameters.from_json(data['grapple_info']),
)
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(),
'grapple_info': self.grapple_info.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_grapple_info(self, asset_manager):
yield from self.grapple_info.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_grapple_info, "grapple_info", "GrappleParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Ripper.{field_name} ({field_type}): {e}"
)
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)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_grapple_info(data: typing.BinaryIO, property_size: int):
return GrappleParameters.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),
0x6a2872d8: ('grapple_info', _decode_grapple_info),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Ripper.py | 0.602529 | 0.322819 | Ripper.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class Coin(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
cone_spread: float = dataclasses.field(default=180.0)
minimum_speed: float = dataclasses.field(default=5.0)
maximum_speed: float = dataclasses.field(default=15.0)
minimum_spin_speed: float = dataclasses.field(default=1.0)
maximum_spin_speed: float = dataclasses.field(default=1.2000000476837158)
minimum_life_time: float = dataclasses.field(default=2.0)
maximum_life_time: float = dataclasses.field(default=3.0)
disable_collision_time: float = dataclasses.field(default=0.0)
fade_in_end_percentage: float = dataclasses.field(default=10.0)
fade_out_start_percentage: float = dataclasses.field(default=80.0)
start_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
end_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
scale_start_percentage: float = dataclasses.field(default=80.0)
final_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_0x417f4a91: float = dataclasses.field(default=0.375)
gravity: float = dataclasses.field(default=25.0)
position_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
particle1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
bounce_sound: int = dataclasses.field(default=0)
max_bounce_sounds: int = dataclasses.field(default=1)
unknown_0x76c79503: float = dataclasses.field(default=1.0)
unknown_0x310dfac8: float = dataclasses.field(default=1.0)
particle_system1_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system1_uses_global_translation: bool = dataclasses.field(default=False)
particle_system1_wait_for_particles_to_die: bool = dataclasses.field(default=False)
particle_system1_orientation: int = dataclasses.field(default=0)
particle2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_system2_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system2_uses_global_translation: bool = dataclasses.field(default=False)
particle_system2_wait_for_particles_to_die: bool = dataclasses.field(default=False)
particle_system2_orientation: int = dataclasses.field(default=0)
death_particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death_particle_system_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
death_particle_system_orientation: int = dataclasses.field(default=0)
is_collider: bool = dataclasses.field(default=True)
is_shootable: bool = dataclasses.field(default=False)
die_on_collision: bool = dataclasses.field(default=False)
unknown_0xdcaa0f22: bool = dataclasses.field(default=False)
unknown_0xbfd82a19: bool = dataclasses.field(default=False)
unknown_0x723d42d6: bool = dataclasses.field(default=True)
disable_physics_threshold: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'COIN'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptCoin.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00,') # 44 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'\x8do\xc3\x91') # 0x8d6fc391
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cone_spread))
data.write(b'\x01\x85&>') # 0x185263e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_speed))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
data.write(b'\x86>\xbbv') # 0x863ebb76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_spin_speed))
data.write(b'\x95{]\xdd') # 0x957b5ddd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_spin_speed))
data.write(b'T\xa8\xc4\x81') # 0x54a8c481
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_life_time))
data.write(b'}\xd69\x99') # 0x7dd63999
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_life_time))
data.write(b'kW\x1b\xa5') # 0x6b571ba5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_collision_time))
data.write(b'P\x05\x1a\x17') # 0x50051a17
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_end_percentage))
data.write(b'cS\xc4\t') # 0x6353c409
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_start_percentage))
data.write(b':V4\xd8') # 0x3a5634d8
data.write(b'\x00\x10') # size
self.start_color.to_stream(data)
data.write(b'Z\xf5\x86}') # 0x5af5867d
data.write(b'\x00\x10') # size
self.end_color.to_stream(data)
data.write(b'\x88n|\x9f') # 0x886e7c9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scale_start_percentage))
data.write(b'\x80\xc2*\n') # 0x80c22a0a
data.write(b'\x00\x0c') # size
self.final_scale.to_stream(data)
data.write(b'A\x7fJ\x91') # 0x417f4a91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x417f4a91))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xef\x90\xf0\x9d') # 0xef90f09d
data.write(b'\x00\x0c') # size
self.position_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A\xddM@') # 0x41dd4d40
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle1))
data.write(b'\x0b\xb3\xcc\xae') # 0xbb3ccae
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.bounce_sound))
data.write(b'\x99\x12\x02\xc3') # 0x991202c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_bounce_sounds))
data.write(b'v\xc7\x95\x03') # 0x76c79503
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76c79503))
data.write(b'1\r\xfa\xc8') # 0x310dfac8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x310dfac8))
data.write(b'\x19\xa6\xf7\x1f') # 0x19a6f71f
data.write(b'\x00\x0c') # size
self.particle_system1_scale.to_stream(data)
data.write(b';\x03\xa0\x1e') # 0x3b03a01e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_uses_global_translation))
data.write(b';\xdd/\xed') # 0x3bdd2fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_wait_for_particles_to_die))
data.write(b'3J4\xbb') # 0x334a34bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.particle_system1_orientation))
data.write(b'\xc7I?\xee') # 0xc7493fee
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle2))
data.write(b'n8%\xef') # 0x6e3825ef
data.write(b'\x00\x0c') # size
self.particle_system2_scale.to_stream(data)
data.write(b'\xc9TM\xe6') # 0xc9544de6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_uses_global_translation))
data.write(b'\xc9\x8a\xc2\x15') # 0xc98ac215
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_wait_for_particles_to_die))
data.write(b'\xd9\xcc\xe9\xd9') # 0xd9cce9d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.particle_system2_orientation))
data.write(b'\x97\x90B\xc8') # 0x979042c8
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_particle))
data.write(b'\xe9!L\xd8') # 0xe9214cd8
data.write(b'\x00\x0c') # size
self.death_particle_system_scale.to_stream(data)
data.write(b'\x9d\xfa\xde\xe0') # 0x9dfadee0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_particle_system_orientation))
data.write(b',{\x18\xdd') # 0x2c7b18dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_collider))
data.write(b'\x8cs\xcb|') # 0x8c73cb7c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_shootable))
data.write(b'\r\x7f\xadU') # 0xd7fad55
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.die_on_collision))
data.write(b'\xdc\xaa\x0f"') # 0xdcaa0f22
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xdcaa0f22))
data.write(b'\xbf\xd8*\x19') # 0xbfd82a19
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbfd82a19))
data.write(b'r=B\xd6') # 0x723d42d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x723d42d6))
data.write(b')_\x05\xb7') # 0x295f05b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_physics_threshold))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
cone_spread=data['cone_spread'],
minimum_speed=data['minimum_speed'],
maximum_speed=data['maximum_speed'],
minimum_spin_speed=data['minimum_spin_speed'],
maximum_spin_speed=data['maximum_spin_speed'],
minimum_life_time=data['minimum_life_time'],
maximum_life_time=data['maximum_life_time'],
disable_collision_time=data['disable_collision_time'],
fade_in_end_percentage=data['fade_in_end_percentage'],
fade_out_start_percentage=data['fade_out_start_percentage'],
start_color=Color.from_json(data['start_color']),
end_color=Color.from_json(data['end_color']),
scale_start_percentage=data['scale_start_percentage'],
final_scale=Vector.from_json(data['final_scale']),
unknown_0x417f4a91=data['unknown_0x417f4a91'],
gravity=data['gravity'],
position_offset=Vector.from_json(data['position_offset']),
model=data['model'],
actor_information=ActorParameters.from_json(data['actor_information']),
particle1=data['particle1'],
bounce_sound=data['bounce_sound'],
max_bounce_sounds=data['max_bounce_sounds'],
unknown_0x76c79503=data['unknown_0x76c79503'],
unknown_0x310dfac8=data['unknown_0x310dfac8'],
particle_system1_scale=Vector.from_json(data['particle_system1_scale']),
particle_system1_uses_global_translation=data['particle_system1_uses_global_translation'],
particle_system1_wait_for_particles_to_die=data['particle_system1_wait_for_particles_to_die'],
particle_system1_orientation=data['particle_system1_orientation'],
particle2=data['particle2'],
particle_system2_scale=Vector.from_json(data['particle_system2_scale']),
particle_system2_uses_global_translation=data['particle_system2_uses_global_translation'],
particle_system2_wait_for_particles_to_die=data['particle_system2_wait_for_particles_to_die'],
particle_system2_orientation=data['particle_system2_orientation'],
death_particle=data['death_particle'],
death_particle_system_scale=Vector.from_json(data['death_particle_system_scale']),
death_particle_system_orientation=data['death_particle_system_orientation'],
is_collider=data['is_collider'],
is_shootable=data['is_shootable'],
die_on_collision=data['die_on_collision'],
unknown_0xdcaa0f22=data['unknown_0xdcaa0f22'],
unknown_0xbfd82a19=data['unknown_0xbfd82a19'],
unknown_0x723d42d6=data['unknown_0x723d42d6'],
disable_physics_threshold=data['disable_physics_threshold'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'cone_spread': self.cone_spread,
'minimum_speed': self.minimum_speed,
'maximum_speed': self.maximum_speed,
'minimum_spin_speed': self.minimum_spin_speed,
'maximum_spin_speed': self.maximum_spin_speed,
'minimum_life_time': self.minimum_life_time,
'maximum_life_time': self.maximum_life_time,
'disable_collision_time': self.disable_collision_time,
'fade_in_end_percentage': self.fade_in_end_percentage,
'fade_out_start_percentage': self.fade_out_start_percentage,
'start_color': self.start_color.to_json(),
'end_color': self.end_color.to_json(),
'scale_start_percentage': self.scale_start_percentage,
'final_scale': self.final_scale.to_json(),
'unknown_0x417f4a91': self.unknown_0x417f4a91,
'gravity': self.gravity,
'position_offset': self.position_offset.to_json(),
'model': self.model,
'actor_information': self.actor_information.to_json(),
'particle1': self.particle1,
'bounce_sound': self.bounce_sound,
'max_bounce_sounds': self.max_bounce_sounds,
'unknown_0x76c79503': self.unknown_0x76c79503,
'unknown_0x310dfac8': self.unknown_0x310dfac8,
'particle_system1_scale': self.particle_system1_scale.to_json(),
'particle_system1_uses_global_translation': self.particle_system1_uses_global_translation,
'particle_system1_wait_for_particles_to_die': self.particle_system1_wait_for_particles_to_die,
'particle_system1_orientation': self.particle_system1_orientation,
'particle2': self.particle2,
'particle_system2_scale': self.particle_system2_scale.to_json(),
'particle_system2_uses_global_translation': self.particle_system2_uses_global_translation,
'particle_system2_wait_for_particles_to_die': self.particle_system2_wait_for_particles_to_die,
'particle_system2_orientation': self.particle_system2_orientation,
'death_particle': self.death_particle,
'death_particle_system_scale': self.death_particle_system_scale.to_json(),
'death_particle_system_orientation': self.death_particle_system_orientation,
'is_collider': self.is_collider,
'is_shootable': self.is_shootable,
'die_on_collision': self.die_on_collision,
'unknown_0xdcaa0f22': self.unknown_0xdcaa0f22,
'unknown_0xbfd82a19': self.unknown_0xbfd82a19,
'unknown_0x723d42d6': self.unknown_0x723d42d6,
'disable_physics_threshold': self.disable_physics_threshold,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_particle1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle1)
def _dependencies_for_particle2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle2)
def _dependencies_for_death_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_particle)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_particle1, "particle1", "AssetId"),
(self._dependencies_for_particle2, "particle2", "AssetId"),
(self._dependencies_for_death_particle, "death_particle", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Coin.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_cone_spread(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_spin_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_spin_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disable_collision_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_end_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_end_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_scale_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_final_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x417f4a91(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_position_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_particle1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_bounce_sounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x76c79503(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x310dfac8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_particle_system1_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system1_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_particle2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_particle_system2_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system2_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_particle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_particle_system_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_death_particle_system_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_is_collider(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_shootable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_die_on_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xdcaa0f22(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbfd82a19(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x723d42d6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_physics_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x8d6fc391: ('cone_spread', _decode_cone_spread),
0x185263e: ('minimum_speed', _decode_minimum_speed),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
0x863ebb76: ('minimum_spin_speed', _decode_minimum_spin_speed),
0x957b5ddd: ('maximum_spin_speed', _decode_maximum_spin_speed),
0x54a8c481: ('minimum_life_time', _decode_minimum_life_time),
0x7dd63999: ('maximum_life_time', _decode_maximum_life_time),
0x6b571ba5: ('disable_collision_time', _decode_disable_collision_time),
0x50051a17: ('fade_in_end_percentage', _decode_fade_in_end_percentage),
0x6353c409: ('fade_out_start_percentage', _decode_fade_out_start_percentage),
0x3a5634d8: ('start_color', _decode_start_color),
0x5af5867d: ('end_color', _decode_end_color),
0x886e7c9f: ('scale_start_percentage', _decode_scale_start_percentage),
0x80c22a0a: ('final_scale', _decode_final_scale),
0x417f4a91: ('unknown_0x417f4a91', _decode_unknown_0x417f4a91),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xef90f09d: ('position_offset', _decode_position_offset),
0xc27ffa8f: ('model', _decode_model),
0x7e397fed: ('actor_information', _decode_actor_information),
0x41dd4d40: ('particle1', _decode_particle1),
0xbb3ccae: ('bounce_sound', _decode_bounce_sound),
0x991202c3: ('max_bounce_sounds', _decode_max_bounce_sounds),
0x76c79503: ('unknown_0x76c79503', _decode_unknown_0x76c79503),
0x310dfac8: ('unknown_0x310dfac8', _decode_unknown_0x310dfac8),
0x19a6f71f: ('particle_system1_scale', _decode_particle_system1_scale),
0x3b03a01e: ('particle_system1_uses_global_translation', _decode_particle_system1_uses_global_translation),
0x3bdd2fed: ('particle_system1_wait_for_particles_to_die', _decode_particle_system1_wait_for_particles_to_die),
0x334a34bb: ('particle_system1_orientation', _decode_particle_system1_orientation),
0xc7493fee: ('particle2', _decode_particle2),
0x6e3825ef: ('particle_system2_scale', _decode_particle_system2_scale),
0xc9544de6: ('particle_system2_uses_global_translation', _decode_particle_system2_uses_global_translation),
0xc98ac215: ('particle_system2_wait_for_particles_to_die', _decode_particle_system2_wait_for_particles_to_die),
0xd9cce9d9: ('particle_system2_orientation', _decode_particle_system2_orientation),
0x979042c8: ('death_particle', _decode_death_particle),
0xe9214cd8: ('death_particle_system_scale', _decode_death_particle_system_scale),
0x9dfadee0: ('death_particle_system_orientation', _decode_death_particle_system_orientation),
0x2c7b18dd: ('is_collider', _decode_is_collider),
0x8c73cb7c: ('is_shootable', _decode_is_shootable),
0xd7fad55: ('die_on_collision', _decode_die_on_collision),
0xdcaa0f22: ('unknown_0xdcaa0f22', _decode_unknown_0xdcaa0f22),
0xbfd82a19: ('unknown_0xbfd82a19', _decode_unknown_0xbfd82a19),
0x723d42d6: ('unknown_0x723d42d6', _decode_unknown_0x723d42d6),
0x295f05b7: ('disable_physics_threshold', _decode_disable_physics_threshold),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Coin.py | 0.685002 | 0.209389 | Coin.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.TextProperties import TextProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Subtitle(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
text_position_x: int = dataclasses.field(default=0)
text_position_y: int = dataclasses.field(default=0)
japan_text_properties: TextProperties = dataclasses.field(default_factory=TextProperties)
japan_text_position_x: int = dataclasses.field(default=0)
japan_text_position_y: int = dataclasses.field(default=100)
string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
initial_string_index: int = dataclasses.field(default=0)
fade_in_time: float = dataclasses.field(default=0.0)
fade_out_time: float = dataclasses.field(default=0.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SUBT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x08') # 8 properties
num_properties_written = 8
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0T>f') # 0xe0543e66
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.text_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc3:\x87\xc7') # 0xc33a87c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_x))
data.write(b'{\x86\xe0\xa2') # 0x7b86e0a2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.text_position_y))
if self.japan_text_properties != default_override.get('japan_text_properties', TextProperties()):
num_properties_written += 1
data.write(b'\xc8\xe4A\xfa') # 0xc8e441fa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.japan_text_properties.to_stream(data, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
if self.japan_text_position_x != default_override.get('japan_text_position_x', 0):
num_properties_written += 1
data.write(b'S\xa7\xf7\xa7') # 0x53a7f7a7
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_x))
if self.japan_text_position_y != default_override.get('japan_text_position_y', 100):
num_properties_written += 1
data.write(b'\xeb\x1b\x90\xc2') # 0xeb1b90c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.japan_text_position_y))
data.write(b'\xfd\x95\xed*') # 0xfd95ed2a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.string_table))
data.write(b'l\xe4f\x89') # 0x6ce46689
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.initial_string_index))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.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']),
text_properties=TextProperties.from_json(data['text_properties']),
text_position_x=data['text_position_x'],
text_position_y=data['text_position_y'],
japan_text_properties=TextProperties.from_json(data['japan_text_properties']),
japan_text_position_x=data['japan_text_position_x'],
japan_text_position_y=data['japan_text_position_y'],
string_table=data['string_table'],
initial_string_index=data['initial_string_index'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'text_properties': self.text_properties.to_json(),
'text_position_x': self.text_position_x,
'text_position_y': self.text_position_y,
'japan_text_properties': self.japan_text_properties.to_json(),
'japan_text_position_x': self.japan_text_position_x,
'japan_text_position_y': self.japan_text_position_y,
'string_table': self.string_table,
'initial_string_index': self.initial_string_index,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_text_properties(self, asset_manager):
yield from self.text_properties.dependencies_for(asset_manager)
def _dependencies_for_japan_text_properties(self, asset_manager):
yield from self.japan_text_properties.dependencies_for(asset_manager)
def _dependencies_for_string_table(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.string_table)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_text_properties, "text_properties", "TextProperties"),
(self._dependencies_for_japan_text_properties, "japan_text_properties", "TextProperties"),
(self._dependencies_for_string_table, "string_table", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Subtitle.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size)
def _decode_text_position_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_properties(data: typing.BinaryIO, property_size: int):
return TextProperties.from_stream(data, property_size, default_override={'text_bounding_width': 640, 'text_bounding_height': 448})
def _decode_japan_text_position_x(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_japan_text_position_y(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_initial_string_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xe0543e66: ('text_properties', _decode_text_properties),
0xc33a87c7: ('text_position_x', _decode_text_position_x),
0x7b86e0a2: ('text_position_y', _decode_text_position_y),
0xc8e441fa: ('japan_text_properties', _decode_japan_text_properties),
0x53a7f7a7: ('japan_text_position_x', _decode_japan_text_position_x),
0xeb1b90c2: ('japan_text_position_y', _decode_japan_text_position_y),
0xfd95ed2a: ('string_table', _decode_string_table),
0x6ce46689: ('initial_string_index', _decode_initial_string_index),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Subtitle.py | 0.558327 | 0.245141 | Subtitle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class Silhouette(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
unknown: float = dataclasses.field(default=0.5)
silhouette_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.2980389893054962, g=0.6000000238418579, b=1.0, a=0.49803900718688965))
fade_in_time: float = dataclasses.field(default=1.0)
fade_out_time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SILH'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x82\xba\xd3\xee') # 0x82bad3ee
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x8c\x8b2\x89') # 0x8c8b3289
data.write(b'\x00\x10') # size
self.silhouette_color.to_stream(data)
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
unknown=data['unknown'],
silhouette_color=Color.from_json(data['silhouette_color']),
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'unknown': self.unknown,
'silhouette_color': self.silhouette_color.to_json(),
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Silhouette.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_silhouette_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x82bad3ee: ('unknown', _decode_unknown),
0x8c8b3289: ('silhouette_color', _decode_silhouette_color),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Silhouette.py | 0.627723 | 0.287319 | Silhouette.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIWaypoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
speed: float = dataclasses.field(default=1.0)
pause: float = dataclasses.field(default=0.0)
unknown_0xc6705a00: int = dataclasses.field(default=0)
locator_index: int = dataclasses.field(default=0)
unknown_0x166979d4: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AIWP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x06') # 6 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'\x80\xf7\xe6\x05') # 0x80f7e605
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.pause))
data.write(b'\xc6pZ\x00') # 0xc6705a00
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xc6705a00))
data.write(b'\xa7\x90\xc6\xa9') # 0xa790c6a9
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.locator_index))
data.write(b'\x16iy\xd4') # 0x166979d4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x166979d4))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
speed=data['speed'],
pause=data['pause'],
unknown_0xc6705a00=data['unknown_0xc6705a00'],
locator_index=data['locator_index'],
unknown_0x166979d4=data['unknown_0x166979d4'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'speed': self.speed,
'pause': self.pause,
'unknown_0xc6705a00': self.unknown_0xc6705a00,
'locator_index': self.locator_index,
'unknown_0x166979d4': self.unknown_0x166979d4,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AIWaypoint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_pause(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc6705a00(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_locator_index(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x166979d4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x6392404e: ('speed', _decode_speed),
0x80f7e605: ('pause', _decode_pause),
0xc6705a00: ('unknown_0xc6705a00', _decode_unknown_0xc6705a00),
0xa790c6a9: ('locator_index', _decode_locator_index),
0x166979d4: ('unknown_0x166979d4', _decode_unknown_0x166979d4),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AIWaypoint.py | 0.583085 | 0.30047 | AIWaypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.ScannableParameters import ScannableParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanTreeScan(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
name_string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
name_string_name: str = dataclasses.field(default='')
scannable_parameters: ScannableParameters = dataclasses.field(default_factory=ScannableParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SCSN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'F!\x9b\xac') # 0x46219bac
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.name_string_table))
data.write(b'2i\x8b\xd6') # 0x32698bd6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.name_string_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'-\xa1\xec3') # 0x2da1ec33
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scannable_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']),
name_string_table=data['name_string_table'],
name_string_name=data['name_string_name'],
scannable_parameters=ScannableParameters.from_json(data['scannable_parameters']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'name_string_table': self.name_string_table,
'name_string_name': self.name_string_name,
'scannable_parameters': self.scannable_parameters.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_name_string_table(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.name_string_table)
def _dependencies_for_scannable_parameters(self, asset_manager):
yield from self.scannable_parameters.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_name_string_table, "name_string_table", "AssetId"),
(self._dependencies_for_scannable_parameters, "scannable_parameters", "ScannableParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScanTreeScan.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_name_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_name_string_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_scannable_parameters(data: typing.BinaryIO, property_size: int):
return ScannableParameters.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),
0x46219bac: ('name_string_table', _decode_name_string_table),
0x32698bd6: ('name_string_name', _decode_name_string_name),
0x2da1ec33: ('scannable_parameters', _decode_scannable_parameters),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ScanTreeScan.py | 0.578329 | 0.282534 | ScanTreeScan.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class WorldLightFader(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
target_light: float = dataclasses.field(default=1.0)
target_light_rate: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'WLIT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xfbg\xa2k') # 0xfb67a26b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_light))
data.write(b'#M\xceR') # 0x234dce52
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.target_light_rate))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
target_light=data['target_light'],
target_light_rate=data['target_light_rate'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'target_light': self.target_light,
'target_light_rate': self.target_light_rate,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for WorldLightFader.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_target_light(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_target_light_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xfb67a26b: ('target_light', _decode_target_light),
0x234dce52: ('target_light_rate', _decode_target_light_rate),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/WorldLightFader.py | 0.661595 | 0.355551 | WorldLightFader.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.echoes as enums
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class RumbleEffect(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
radius: float = dataclasses.field(default=20.0)
effect: enums.Effect = dataclasses.field(default=enums.Effect.Normal)
flags_rumble: int = dataclasses.field(default=0) # Flagset
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RUMB'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\xc5\x07\xeb') # 0x78c507eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.radius))
data.write(b'h\xac\xbd\x86') # 0x68acbd86
data.write(b'\x00\x04') # size
self.effect.to_stream(data)
data.write(b'O\x7f\xec9') # 0x4f7fec39
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.flags_rumble))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
radius=data['radius'],
effect=enums.Effect.from_json(data['effect']),
flags_rumble=data['flags_rumble'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'radius': self.radius,
'effect': self.effect.to_json(),
'flags_rumble': self.flags_rumble,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for RumbleEffect.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_effect(data: typing.BinaryIO, property_size: int):
return enums.Effect.from_stream(data)
def _decode_flags_rumble(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),
0x78c507eb: ('radius', _decode_radius),
0x68acbd86: ('effect', _decode_effect),
0x4f7fec39: ('flags_rumble', _decode_flags_rumble),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/RumbleEffect.py | 0.610453 | 0.332785 | RumbleEffect.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TweakGame.CoinLimitChoices import CoinLimitChoices
from retro_data_structures.properties.echoes.archetypes.TweakGame.FragLimitChoices import FragLimitChoices
from retro_data_structures.properties.echoes.archetypes.TweakGame.TimeLimitChoices import TimeLimitChoices
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class TweakGame(BaseObjectType):
instance_name: str = dataclasses.field(default='')
pak_file: str = dataclasses.field(default='')
asset: str = dataclasses.field(default='')
fieldof_view: float = dataclasses.field(default=55.0)
fieldof_view2_player: float = dataclasses.field(default=45.0)
disable_debug_menu: bool = dataclasses.field(default=False)
unknown_0x7262d27b: bool = dataclasses.field(default=True)
development_mode: bool = dataclasses.field(default=True)
unknown_0xa3dcf42a: float = dataclasses.field(default=25.0)
unknown_0xb35c72be: float = dataclasses.field(default=1.0)
unknown_0x4a02103c: float = dataclasses.field(default=30.0)
unknown_0xe1fca71b: float = dataclasses.field(default=125.0)
unknown_0xfbce966a: float = dataclasses.field(default=150.0)
unknown_0x09c6ca10: float = dataclasses.field(default=300.0)
hard_mode_damage_multiplier: float = dataclasses.field(default=1.5299999713897705)
hard_mode_weapon_multiplier: float = dataclasses.field(default=0.5)
unknown_0x5ab5812c: float = dataclasses.field(default=0.15000000596046448)
unknown_0x53401390: float = dataclasses.field(default=0.15000000596046448)
total_percentage: int = dataclasses.field(default=102)
unknown_0x1d627808: FragLimitChoices = dataclasses.field(default_factory=FragLimitChoices)
unknown_0xb2e8828d: TimeLimitChoices = dataclasses.field(default_factory=TimeLimitChoices)
unknown_0x06af87bd: CoinLimitChoices = dataclasses.field(default_factory=CoinLimitChoices)
unknown_0x1533ea4e: TimeLimitChoices = dataclasses.field(default_factory=TimeLimitChoices)
unknown_0x40818220: Spline = dataclasses.field(default_factory=Spline)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWGM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x18') # 24 properties
data.write(b'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+\xd1:\xb3') # 0x2bd13ab3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.pak_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'\xf8\xbe\x00Z') # 0xf8be005a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.asset.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'\xfc\x93\xce\xb8') # 0xfc93ceb8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fieldof_view))
data.write(b'\x9f\xb2\xfa\xa6') # 0x9fb2faa6
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fieldof_view2_player))
data.write(b'\xa9\ti\x14') # 0xa9096914
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.disable_debug_menu))
data.write(b'rb\xd2{') # 0x7262d27b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x7262d27b))
data.write(b'\xe9C\xba\x12') # 0xe943ba12
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.development_mode))
data.write(b'\xa3\xdc\xf4*') # 0xa3dcf42a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa3dcf42a))
data.write(b'\xb3\\r\xbe') # 0xb35c72be
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb35c72be))
data.write(b'J\x02\x10<') # 0x4a02103c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4a02103c))
data.write(b'\xe1\xfc\xa7\x1b') # 0xe1fca71b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe1fca71b))
data.write(b'\xfb\xce\x96j') # 0xfbce966a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xfbce966a))
data.write(b'\t\xc6\xca\x10') # 0x9c6ca10
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x09c6ca10))
data.write(b'M\xfc\xd42') # 0x4dfcd432
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hard_mode_damage_multiplier))
data.write(b'\xae\x181\xd9') # 0xae1831d9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hard_mode_weapon_multiplier))
data.write(b'Z\xb5\x81,') # 0x5ab5812c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5ab5812c))
data.write(b'S@\x13\x90') # 0x53401390
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x53401390))
data.write(b'\xd0\x9f7;') # 0xd09f373b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.total_percentage))
data.write(b'\x1dbx\x08') # 0x1d627808
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1d627808.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb2\xe8\x82\x8d') # 0xb2e8828d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb2e8828d.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x06\xaf\x87\xbd') # 0x6af87bd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x06af87bd.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x153\xeaN') # 0x1533ea4e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x1533ea4e.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@\x81\x82 ') # 0x40818220
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0x40818220.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(
instance_name=data['instance_name'],
pak_file=data['pak_file'],
asset=data['asset'],
fieldof_view=data['fieldof_view'],
fieldof_view2_player=data['fieldof_view2_player'],
disable_debug_menu=data['disable_debug_menu'],
unknown_0x7262d27b=data['unknown_0x7262d27b'],
development_mode=data['development_mode'],
unknown_0xa3dcf42a=data['unknown_0xa3dcf42a'],
unknown_0xb35c72be=data['unknown_0xb35c72be'],
unknown_0x4a02103c=data['unknown_0x4a02103c'],
unknown_0xe1fca71b=data['unknown_0xe1fca71b'],
unknown_0xfbce966a=data['unknown_0xfbce966a'],
unknown_0x09c6ca10=data['unknown_0x09c6ca10'],
hard_mode_damage_multiplier=data['hard_mode_damage_multiplier'],
hard_mode_weapon_multiplier=data['hard_mode_weapon_multiplier'],
unknown_0x5ab5812c=data['unknown_0x5ab5812c'],
unknown_0x53401390=data['unknown_0x53401390'],
total_percentage=data['total_percentage'],
unknown_0x1d627808=FragLimitChoices.from_json(data['unknown_0x1d627808']),
unknown_0xb2e8828d=TimeLimitChoices.from_json(data['unknown_0xb2e8828d']),
unknown_0x06af87bd=CoinLimitChoices.from_json(data['unknown_0x06af87bd']),
unknown_0x1533ea4e=TimeLimitChoices.from_json(data['unknown_0x1533ea4e']),
unknown_0x40818220=Spline.from_json(data['unknown_0x40818220']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'pak_file': self.pak_file,
'asset': self.asset,
'fieldof_view': self.fieldof_view,
'fieldof_view2_player': self.fieldof_view2_player,
'disable_debug_menu': self.disable_debug_menu,
'unknown_0x7262d27b': self.unknown_0x7262d27b,
'development_mode': self.development_mode,
'unknown_0xa3dcf42a': self.unknown_0xa3dcf42a,
'unknown_0xb35c72be': self.unknown_0xb35c72be,
'unknown_0x4a02103c': self.unknown_0x4a02103c,
'unknown_0xe1fca71b': self.unknown_0xe1fca71b,
'unknown_0xfbce966a': self.unknown_0xfbce966a,
'unknown_0x09c6ca10': self.unknown_0x09c6ca10,
'hard_mode_damage_multiplier': self.hard_mode_damage_multiplier,
'hard_mode_weapon_multiplier': self.hard_mode_weapon_multiplier,
'unknown_0x5ab5812c': self.unknown_0x5ab5812c,
'unknown_0x53401390': self.unknown_0x53401390,
'total_percentage': self.total_percentage,
'unknown_0x1d627808': self.unknown_0x1d627808.to_json(),
'unknown_0xb2e8828d': self.unknown_0xb2e8828d.to_json(),
'unknown_0x06af87bd': self.unknown_0x06af87bd.to_json(),
'unknown_0x1533ea4e': self.unknown_0x1533ea4e.to_json(),
'unknown_0x40818220': self.unknown_0x40818220.to_json(),
}
def _dependencies_for_unknown_0x1d627808(self, asset_manager):
yield from self.unknown_0x1d627808.dependencies_for(asset_manager)
def _dependencies_for_unknown_0xb2e8828d(self, asset_manager):
yield from self.unknown_0xb2e8828d.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x06af87bd(self, asset_manager):
yield from self.unknown_0x06af87bd.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x1533ea4e(self, asset_manager):
yield from self.unknown_0x1533ea4e.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_unknown_0x1d627808, "unknown_0x1d627808", "FragLimitChoices"),
(self._dependencies_for_unknown_0xb2e8828d, "unknown_0xb2e8828d", "TimeLimitChoices"),
(self._dependencies_for_unknown_0x06af87bd, "unknown_0x06af87bd", "CoinLimitChoices"),
(self._dependencies_for_unknown_0x1533ea4e, "unknown_0x1533ea4e", "TimeLimitChoices"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakGame.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_pak_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_asset(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_fieldof_view(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fieldof_view2_player(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disable_debug_menu(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x7262d27b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_development_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xa3dcf42a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb35c72be(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4a02103c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xe1fca71b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfbce966a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x09c6ca10(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hard_mode_damage_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hard_mode_weapon_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5ab5812c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x53401390(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_total_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x1d627808(data: typing.BinaryIO, property_size: int):
return FragLimitChoices.from_stream(data, property_size)
def _decode_unknown_0xb2e8828d(data: typing.BinaryIO, property_size: int):
return TimeLimitChoices.from_stream(data, property_size)
def _decode_unknown_0x06af87bd(data: typing.BinaryIO, property_size: int):
return CoinLimitChoices.from_stream(data, property_size)
def _decode_unknown_0x1533ea4e(data: typing.BinaryIO, property_size: int):
return TimeLimitChoices.from_stream(data, property_size)
def _decode_unknown_0x40818220(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]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0x2bd13ab3: ('pak_file', _decode_pak_file),
0xf8be005a: ('asset', _decode_asset),
0xfc93ceb8: ('fieldof_view', _decode_fieldof_view),
0x9fb2faa6: ('fieldof_view2_player', _decode_fieldof_view2_player),
0xa9096914: ('disable_debug_menu', _decode_disable_debug_menu),
0x7262d27b: ('unknown_0x7262d27b', _decode_unknown_0x7262d27b),
0xe943ba12: ('development_mode', _decode_development_mode),
0xa3dcf42a: ('unknown_0xa3dcf42a', _decode_unknown_0xa3dcf42a),
0xb35c72be: ('unknown_0xb35c72be', _decode_unknown_0xb35c72be),
0x4a02103c: ('unknown_0x4a02103c', _decode_unknown_0x4a02103c),
0xe1fca71b: ('unknown_0xe1fca71b', _decode_unknown_0xe1fca71b),
0xfbce966a: ('unknown_0xfbce966a', _decode_unknown_0xfbce966a),
0x9c6ca10: ('unknown_0x09c6ca10', _decode_unknown_0x09c6ca10),
0x4dfcd432: ('hard_mode_damage_multiplier', _decode_hard_mode_damage_multiplier),
0xae1831d9: ('hard_mode_weapon_multiplier', _decode_hard_mode_weapon_multiplier),
0x5ab5812c: ('unknown_0x5ab5812c', _decode_unknown_0x5ab5812c),
0x53401390: ('unknown_0x53401390', _decode_unknown_0x53401390),
0xd09f373b: ('total_percentage', _decode_total_percentage),
0x1d627808: ('unknown_0x1d627808', _decode_unknown_0x1d627808),
0xb2e8828d: ('unknown_0xb2e8828d', _decode_unknown_0xb2e8828d),
0x6af87bd: ('unknown_0x06af87bd', _decode_unknown_0x06af87bd),
0x1533ea4e: ('unknown_0x1533ea4e', _decode_unknown_0x1533ea4e),
0x40818220: ('unknown_0x40818220', _decode_unknown_0x40818220),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakGame.py | 0.517327 | 0.226698 | TweakGame.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanTreeSlider(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
name_string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
name_string_name: str = dataclasses.field(default='')
unknown: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SCSL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'F!\x9b\xac') # 0x46219bac
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.name_string_table))
data.write(b'2i\x8b\xd6') # 0x32698bd6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.name_string_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x02a\xa4\xe0') # 0x261a4e0
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
name_string_table=data['name_string_table'],
name_string_name=data['name_string_name'],
unknown=data['unknown'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'name_string_table': self.name_string_table,
'name_string_name': self.name_string_name,
'unknown': self.unknown,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_name_string_table(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.name_string_table)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_name_string_table, "name_string_table", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScanTreeSlider.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_name_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_name_string_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x46219bac: ('name_string_table', _decode_name_string_table),
0x32698bd6: ('name_string_name', _decode_name_string_name),
0x261a4e0: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ScanTreeSlider.py | 0.549399 | 0.298204 | ScanTreeSlider.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.CameraShakerData import CameraShakerData
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Spline import Spline
@dataclasses.dataclass()
class MediumIng(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
spawn_mode: int = dataclasses.field(default=0)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
aggressiveness: float = dataclasses.field(default=50.0)
unknown_0x4d1d840d: float = dataclasses.field(default=4.0)
min_melee_attack_interval: float = dataclasses.field(default=10.0)
max_melee_attack_range: float = dataclasses.field(default=20.0)
melee_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x636f11e5: float = dataclasses.field(default=10.0)
mist_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
min_mist_attack_interval: float = dataclasses.field(default=10.0)
misting_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
min_arm_attack_interval: float = dataclasses.field(default=2.0)
unknown_0x9d3cfeb0: float = dataclasses.field(default=15.0)
unknown_0xdc2bc136: float = dataclasses.field(default=30.0)
min_tentacle_length: float = dataclasses.field(default=5.0)
max_tentacle_length: float = dataclasses.field(default=40.0)
arm_attack_time: float = dataclasses.field(default=1.0)
unknown_0x8f1d597c: float = dataclasses.field(default=0.5)
attack_tentacle: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_parameters: ActorParameters = dataclasses.field(default_factory=ActorParameters)
attack_motion: Spline = dataclasses.field(default_factory=Spline)
camera_shaker_data: CameraShakerData = dataclasses.field(default_factory=CameraShakerData)
attack_tentacle_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
taunt_chance: float = dataclasses.field(default=25.0)
double_dash_chance: float = dataclasses.field(default=25.0)
light_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
light_attenuation: float = dataclasses.field(default=2.0)
unknown_0xb459c3e9: Spline = dataclasses.field(default_factory=Spline)
dash_speed: Spline = dataclasses.field(default_factory=Spline)
ing_spot_blob_fx: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
ing_spot_sound: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x0e3d3708: float = dataclasses.field(default=50.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MING'
@classmethod
def modules(cls) -> typing.List[str]:
return ['GeomBlobV2.rel', 'MediumIng.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 360.0, 'creature_size': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc9j\xe3\xdf') # 0xc96ae3df
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.spawn_mode))
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'\x95y\xb1\xf2') # 0x9579b1f2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.aggressiveness))
data.write(b'M\x1d\x84\r') # 0x4d1d840d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4d1d840d))
data.write(b'\xd1\x89\xa7\xaa') # 0xd189a7aa
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_melee_attack_interval))
data.write(b'\xf3\xea-\xef') # 0xf3ea2def
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_melee_attack_range))
data.write(b'\xc9A`4') # 0xc9416034
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.melee_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'co\x11\xe5') # 0x636f11e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x636f11e5))
data.write(b'\xd2%D0') # 0xd2254430
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mist_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb7\x87\xf4\x12') # 0xb787f412
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_mist_attack_interval))
data.write(b'I\xc8\xd0\xc7') # 0x49c8d0c7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.misting_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x15)I\x00') # 0x15294900
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_arm_attack_interval))
data.write(b'\x9d<\xfe\xb0') # 0x9d3cfeb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x9d3cfeb0))
data.write(b'\xdc+\xc16') # 0xdc2bc136
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xdc2bc136))
data.write(b't\xff\xed\x99') # 0x74ffed99
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_tentacle_length))
data.write(b'5\xe8\xd2\x1f') # 0x35e8d21f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_tentacle_length))
data.write(b'\xb95s\xf7') # 0xb93573f7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.arm_attack_time))
data.write(b'\x8f\x1dY|') # 0x8f1d597c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x8f1d597c))
data.write(b'z\x9f\x82I') # 0x7a9f8249
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_tentacle.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'8\xcf\x13;') # 0x38cf133b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_parameters.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x07g\x06\r') # 0x767060d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_motion.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x0ek\x1ep') # 0xe6b1e70
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.camera_shaker_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf6\x83\xfe\x08') # 0xf683fe08
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.attack_tentacle_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xa7\x7fb\x12') # 0xa77f6212
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.taunt_chance))
data.write(b'\x9c\xf0\x14s') # 0x9cf01473
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.double_dash_chance))
data.write(b'\xbd>\xfe}') # 0xbd3efe7d
data.write(b'\x00\x10') # size
self.light_color.to_stream(data)
data.write(b'\xd2K\x88\x8f') # 0xd24b888f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.light_attenuation))
data.write(b'\xb4Y\xc3\xe9') # 0xb459c3e9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_0xb459c3e9.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'2>N\xd0') # 0x323e4ed0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.dash_speed.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x07\x9b\xc5v') # 0x79bc576
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.ing_spot_blob_fx))
data.write(b'|\xb6<\xd3') # 0x7cb63cd3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.ing_spot_sound))
data.write(b'\x0e=7\x08') # 0xe3d3708
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0e3d3708))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
spawn_mode=data['spawn_mode'],
actor_information=ActorParameters.from_json(data['actor_information']),
aggressiveness=data['aggressiveness'],
unknown_0x4d1d840d=data['unknown_0x4d1d840d'],
min_melee_attack_interval=data['min_melee_attack_interval'],
max_melee_attack_range=data['max_melee_attack_range'],
melee_damage=DamageInfo.from_json(data['melee_damage']),
unknown_0x636f11e5=data['unknown_0x636f11e5'],
mist_damage=DamageInfo.from_json(data['mist_damage']),
min_mist_attack_interval=data['min_mist_attack_interval'],
misting_vulnerability=DamageVulnerability.from_json(data['misting_vulnerability']),
min_arm_attack_interval=data['min_arm_attack_interval'],
unknown_0x9d3cfeb0=data['unknown_0x9d3cfeb0'],
unknown_0xdc2bc136=data['unknown_0xdc2bc136'],
min_tentacle_length=data['min_tentacle_length'],
max_tentacle_length=data['max_tentacle_length'],
arm_attack_time=data['arm_attack_time'],
unknown_0x8f1d597c=data['unknown_0x8f1d597c'],
attack_tentacle=AnimationParameters.from_json(data['attack_tentacle']),
actor_parameters=ActorParameters.from_json(data['actor_parameters']),
attack_motion=Spline.from_json(data['attack_motion']),
camera_shaker_data=CameraShakerData.from_json(data['camera_shaker_data']),
attack_tentacle_damage=DamageInfo.from_json(data['attack_tentacle_damage']),
taunt_chance=data['taunt_chance'],
double_dash_chance=data['double_dash_chance'],
light_color=Color.from_json(data['light_color']),
light_attenuation=data['light_attenuation'],
unknown_0xb459c3e9=Spline.from_json(data['unknown_0xb459c3e9']),
dash_speed=Spline.from_json(data['dash_speed']),
ing_spot_blob_fx=data['ing_spot_blob_fx'],
ing_spot_sound=data['ing_spot_sound'],
unknown_0x0e3d3708=data['unknown_0x0e3d3708'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'spawn_mode': self.spawn_mode,
'actor_information': self.actor_information.to_json(),
'aggressiveness': self.aggressiveness,
'unknown_0x4d1d840d': self.unknown_0x4d1d840d,
'min_melee_attack_interval': self.min_melee_attack_interval,
'max_melee_attack_range': self.max_melee_attack_range,
'melee_damage': self.melee_damage.to_json(),
'unknown_0x636f11e5': self.unknown_0x636f11e5,
'mist_damage': self.mist_damage.to_json(),
'min_mist_attack_interval': self.min_mist_attack_interval,
'misting_vulnerability': self.misting_vulnerability.to_json(),
'min_arm_attack_interval': self.min_arm_attack_interval,
'unknown_0x9d3cfeb0': self.unknown_0x9d3cfeb0,
'unknown_0xdc2bc136': self.unknown_0xdc2bc136,
'min_tentacle_length': self.min_tentacle_length,
'max_tentacle_length': self.max_tentacle_length,
'arm_attack_time': self.arm_attack_time,
'unknown_0x8f1d597c': self.unknown_0x8f1d597c,
'attack_tentacle': self.attack_tentacle.to_json(),
'actor_parameters': self.actor_parameters.to_json(),
'attack_motion': self.attack_motion.to_json(),
'camera_shaker_data': self.camera_shaker_data.to_json(),
'attack_tentacle_damage': self.attack_tentacle_damage.to_json(),
'taunt_chance': self.taunt_chance,
'double_dash_chance': self.double_dash_chance,
'light_color': self.light_color.to_json(),
'light_attenuation': self.light_attenuation,
'unknown_0xb459c3e9': self.unknown_0xb459c3e9.to_json(),
'dash_speed': self.dash_speed.to_json(),
'ing_spot_blob_fx': self.ing_spot_blob_fx,
'ing_spot_sound': self.ing_spot_sound,
'unknown_0x0e3d3708': self.unknown_0x0e3d3708,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_melee_damage(self, asset_manager):
yield from self.melee_damage.dependencies_for(asset_manager)
def _dependencies_for_mist_damage(self, asset_manager):
yield from self.mist_damage.dependencies_for(asset_manager)
def _dependencies_for_misting_vulnerability(self, asset_manager):
yield from self.misting_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_attack_tentacle(self, asset_manager):
yield from self.attack_tentacle.dependencies_for(asset_manager)
def _dependencies_for_actor_parameters(self, asset_manager):
yield from self.actor_parameters.dependencies_for(asset_manager)
def _dependencies_for_camera_shaker_data(self, asset_manager):
yield from self.camera_shaker_data.dependencies_for(asset_manager)
def _dependencies_for_attack_tentacle_damage(self, asset_manager):
yield from self.attack_tentacle_damage.dependencies_for(asset_manager)
def _dependencies_for_ing_spot_blob_fx(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.ing_spot_blob_fx)
def _dependencies_for_ing_spot_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.ing_spot_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_melee_damage, "melee_damage", "DamageInfo"),
(self._dependencies_for_mist_damage, "mist_damage", "DamageInfo"),
(self._dependencies_for_misting_vulnerability, "misting_vulnerability", "DamageVulnerability"),
(self._dependencies_for_attack_tentacle, "attack_tentacle", "AnimationParameters"),
(self._dependencies_for_actor_parameters, "actor_parameters", "ActorParameters"),
(self._dependencies_for_camera_shaker_data, "camera_shaker_data", "CameraShakerData"),
(self._dependencies_for_attack_tentacle_damage, "attack_tentacle_damage", "DamageInfo"),
(self._dependencies_for_ing_spot_blob_fx, "ing_spot_blob_fx", "AssetId"),
(self._dependencies_for_ing_spot_sound, "ing_spot_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MediumIng.{field_name} ({field_type}): {e}"
)
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, 'creature_size': 1})
def _decode_spawn_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_aggressiveness(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4d1d840d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_melee_attack_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_melee_attack_range(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_melee_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown_0x636f11e5(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mist_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_min_mist_attack_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_misting_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_min_arm_attack_interval(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x9d3cfeb0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xdc2bc136(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_tentacle_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_tentacle_length(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_arm_attack_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x8f1d597c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_tentacle(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_actor_parameters(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_attack_motion(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_camera_shaker_data(data: typing.BinaryIO, property_size: int):
return CameraShakerData.from_stream(data, property_size)
def _decode_attack_tentacle_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_taunt_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_double_dash_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_light_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_light_attenuation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb459c3e9(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_dash_speed(data: typing.BinaryIO, property_size: int):
return Spline.from_stream(data, property_size)
def _decode_ing_spot_blob_fx(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_ing_spot_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x0e3d3708(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),
0xb3774750: ('patterned', _decode_patterned),
0xc96ae3df: ('spawn_mode', _decode_spawn_mode),
0x7e397fed: ('actor_information', _decode_actor_information),
0x9579b1f2: ('aggressiveness', _decode_aggressiveness),
0x4d1d840d: ('unknown_0x4d1d840d', _decode_unknown_0x4d1d840d),
0xd189a7aa: ('min_melee_attack_interval', _decode_min_melee_attack_interval),
0xf3ea2def: ('max_melee_attack_range', _decode_max_melee_attack_range),
0xc9416034: ('melee_damage', _decode_melee_damage),
0x636f11e5: ('unknown_0x636f11e5', _decode_unknown_0x636f11e5),
0xd2254430: ('mist_damage', _decode_mist_damage),
0xb787f412: ('min_mist_attack_interval', _decode_min_mist_attack_interval),
0x49c8d0c7: ('misting_vulnerability', _decode_misting_vulnerability),
0x15294900: ('min_arm_attack_interval', _decode_min_arm_attack_interval),
0x9d3cfeb0: ('unknown_0x9d3cfeb0', _decode_unknown_0x9d3cfeb0),
0xdc2bc136: ('unknown_0xdc2bc136', _decode_unknown_0xdc2bc136),
0x74ffed99: ('min_tentacle_length', _decode_min_tentacle_length),
0x35e8d21f: ('max_tentacle_length', _decode_max_tentacle_length),
0xb93573f7: ('arm_attack_time', _decode_arm_attack_time),
0x8f1d597c: ('unknown_0x8f1d597c', _decode_unknown_0x8f1d597c),
0x7a9f8249: ('attack_tentacle', _decode_attack_tentacle),
0x38cf133b: ('actor_parameters', _decode_actor_parameters),
0x767060d: ('attack_motion', _decode_attack_motion),
0xe6b1e70: ('camera_shaker_data', _decode_camera_shaker_data),
0xf683fe08: ('attack_tentacle_damage', _decode_attack_tentacle_damage),
0xa77f6212: ('taunt_chance', _decode_taunt_chance),
0x9cf01473: ('double_dash_chance', _decode_double_dash_chance),
0xbd3efe7d: ('light_color', _decode_light_color),
0xd24b888f: ('light_attenuation', _decode_light_attenuation),
0xb459c3e9: ('unknown_0xb459c3e9', _decode_unknown_0xb459c3e9),
0x323e4ed0: ('dash_speed', _decode_dash_speed),
0x79bc576: ('ing_spot_blob_fx', _decode_ing_spot_blob_fx),
0x7cb63cd3: ('ing_spot_sound', _decode_ing_spot_sound),
0xe3d3708: ('unknown_0x0e3d3708', _decode_unknown_0x0e3d3708),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/MediumIng.py | 0.666822 | 0.220584 | MediumIng.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MetroidAlpha(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
frozen_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
energy_drain_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
damage_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
unknown_0x72439b39: float = dataclasses.field(default=5.0)
unknown_0x3af75fcc: float = dataclasses.field(default=40.0)
telegraph_attack_time: float = dataclasses.field(default=1.0)
baby_metroid_scale: float = dataclasses.field(default=0.5)
unknown_0x03362858: float = dataclasses.field(default=10.0)
unknown_0x852d3bb0: float = dataclasses.field(default=10.0)
unknown_0x1c783744: float = dataclasses.field(default=0.5)
part: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0x2fe164c4: float = dataclasses.field(default=1.75)
unknown_0x4c1f78f3: float = dataclasses.field(default=50.0)
unknown_0x5f3f294c: float = dataclasses.field(default=100.0)
unknown_0x06b460f4: float = dataclasses.field(default=5.0)
chance_to_dodge: float = dataclasses.field(default=0.5)
unknown_0xfa51d735: int = dataclasses.field(default=0)
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MTDA'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Metroid.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 180.0, 'detection_range': 60.0, 'max_attack_range': 10.0, 'average_attack_time': 6.0, 'attack_time_variation': 5.0, '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'A\x198\xaa') # 0x411938aa
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.frozen_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd8n\xe9?') # 0xd86ee93f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.energy_drain_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'9\xd60\x82') # 0x39d63082
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'rC\x9b9') # 0x72439b39
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x72439b39))
data.write(b':\xf7_\xcc') # 0x3af75fcc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3af75fcc))
data.write(b'\xa9~\xdc\x02') # 0xa97edc02
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.telegraph_attack_time))
data.write(b'\r~~,') # 0xd7e7e2c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.baby_metroid_scale))
data.write(b'\x036(X') # 0x3362858
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x03362858))
data.write(b'\x85-;\xb0') # 0x852d3bb0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x852d3bb0))
data.write(b'\x1cx7D') # 0x1c783744
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1c783744))
data.write(b'q\xa2\x1bP') # 0x71a21b50
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.part))
data.write(b'/\xe1d\xc4') # 0x2fe164c4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2fe164c4))
data.write(b'L\x1fx\xf3') # 0x4c1f78f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x4c1f78f3))
data.write(b'_?)L') # 0x5f3f294c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x5f3f294c))
data.write(b'\x06\xb4`\xf4') # 0x6b460f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x06b460f4))
data.write(b'#\xca\x06v') # 0x23ca0676
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.chance_to_dodge))
data.write(b'\xfaQ\xd75') # 0xfa51d735
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xfa51d735))
data.write(b'\xe6\x17H\xed') # 0xe61748ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_possession_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']),
frozen_vulnerability=DamageVulnerability.from_json(data['frozen_vulnerability']),
energy_drain_vulnerability=DamageVulnerability.from_json(data['energy_drain_vulnerability']),
damage_vulnerability=DamageVulnerability.from_json(data['damage_vulnerability']),
unknown_0x72439b39=data['unknown_0x72439b39'],
unknown_0x3af75fcc=data['unknown_0x3af75fcc'],
telegraph_attack_time=data['telegraph_attack_time'],
baby_metroid_scale=data['baby_metroid_scale'],
unknown_0x03362858=data['unknown_0x03362858'],
unknown_0x852d3bb0=data['unknown_0x852d3bb0'],
unknown_0x1c783744=data['unknown_0x1c783744'],
part=data['part'],
unknown_0x2fe164c4=data['unknown_0x2fe164c4'],
unknown_0x4c1f78f3=data['unknown_0x4c1f78f3'],
unknown_0x5f3f294c=data['unknown_0x5f3f294c'],
unknown_0x06b460f4=data['unknown_0x06b460f4'],
chance_to_dodge=data['chance_to_dodge'],
unknown_0xfa51d735=data['unknown_0xfa51d735'],
ing_possession_data=IngPossessionData.from_json(data['ing_possession_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(),
'frozen_vulnerability': self.frozen_vulnerability.to_json(),
'energy_drain_vulnerability': self.energy_drain_vulnerability.to_json(),
'damage_vulnerability': self.damage_vulnerability.to_json(),
'unknown_0x72439b39': self.unknown_0x72439b39,
'unknown_0x3af75fcc': self.unknown_0x3af75fcc,
'telegraph_attack_time': self.telegraph_attack_time,
'baby_metroid_scale': self.baby_metroid_scale,
'unknown_0x03362858': self.unknown_0x03362858,
'unknown_0x852d3bb0': self.unknown_0x852d3bb0,
'unknown_0x1c783744': self.unknown_0x1c783744,
'part': self.part,
'unknown_0x2fe164c4': self.unknown_0x2fe164c4,
'unknown_0x4c1f78f3': self.unknown_0x4c1f78f3,
'unknown_0x5f3f294c': self.unknown_0x5f3f294c,
'unknown_0x06b460f4': self.unknown_0x06b460f4,
'chance_to_dodge': self.chance_to_dodge,
'unknown_0xfa51d735': self.unknown_0xfa51d735,
'ing_possession_data': self.ing_possession_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_frozen_vulnerability(self, asset_manager):
yield from self.frozen_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_energy_drain_vulnerability(self, asset_manager):
yield from self.energy_drain_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_damage_vulnerability(self, asset_manager):
yield from self.damage_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_part(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.part)
def _dependencies_for_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_frozen_vulnerability, "frozen_vulnerability", "DamageVulnerability"),
(self._dependencies_for_energy_drain_vulnerability, "energy_drain_vulnerability", "DamageVulnerability"),
(self._dependencies_for_damage_vulnerability, "damage_vulnerability", "DamageVulnerability"),
(self._dependencies_for_part, "part", "AssetId"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MetroidAlpha.{field_name} ({field_type}): {e}"
)
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': 180.0, 'detection_range': 60.0, 'max_attack_range': 10.0, 'average_attack_time': 6.0, 'attack_time_variation': 5.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_frozen_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_energy_drain_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_damage_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_unknown_0x72439b39(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3af75fcc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_telegraph_attack_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_baby_metroid_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x03362858(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x852d3bb0(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1c783744(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_part(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0x2fe164c4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x4c1f78f3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x5f3f294c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x06b460f4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_chance_to_dodge(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfa51d735(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_ing_possession_data(data: typing.BinaryIO, property_size: int):
return IngPossessionData.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),
0x411938aa: ('frozen_vulnerability', _decode_frozen_vulnerability),
0xd86ee93f: ('energy_drain_vulnerability', _decode_energy_drain_vulnerability),
0x39d63082: ('damage_vulnerability', _decode_damage_vulnerability),
0x72439b39: ('unknown_0x72439b39', _decode_unknown_0x72439b39),
0x3af75fcc: ('unknown_0x3af75fcc', _decode_unknown_0x3af75fcc),
0xa97edc02: ('telegraph_attack_time', _decode_telegraph_attack_time),
0xd7e7e2c: ('baby_metroid_scale', _decode_baby_metroid_scale),
0x3362858: ('unknown_0x03362858', _decode_unknown_0x03362858),
0x852d3bb0: ('unknown_0x852d3bb0', _decode_unknown_0x852d3bb0),
0x1c783744: ('unknown_0x1c783744', _decode_unknown_0x1c783744),
0x71a21b50: ('part', _decode_part),
0x2fe164c4: ('unknown_0x2fe164c4', _decode_unknown_0x2fe164c4),
0x4c1f78f3: ('unknown_0x4c1f78f3', _decode_unknown_0x4c1f78f3),
0x5f3f294c: ('unknown_0x5f3f294c', _decode_unknown_0x5f3f294c),
0x6b460f4: ('unknown_0x06b460f4', _decode_unknown_0x06b460f4),
0x23ca0676: ('chance_to_dodge', _decode_chance_to_dodge),
0xfa51d735: ('unknown_0xfa51d735', _decode_unknown_0xfa51d735),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/MetroidAlpha.py | 0.573559 | 0.269217 | MetroidAlpha.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.IngPossessionData import IngPossessionData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.SwampBossStage2Data import SwampBossStage2Data
@dataclasses.dataclass()
class SwampBossStage2(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
ing_possession_data: IngPossessionData = dataclasses.field(default_factory=IngPossessionData)
swamp_boss_stage2_data: SwampBossStage2Data = dataclasses.field(default_factory=SwampBossStage2Data)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SBS2'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SwampBossStage2.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5, 'creature_size': 2})
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\x17H\xed') # 0xe61748ed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.ing_possession_data.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3\x1bw\x1d') # 0xb31b771d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.swamp_boss_stage2_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']),
ing_possession_data=IngPossessionData.from_json(data['ing_possession_data']),
swamp_boss_stage2_data=SwampBossStage2Data.from_json(data['swamp_boss_stage2_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(),
'ing_possession_data': self.ing_possession_data.to_json(),
'swamp_boss_stage2_data': self.swamp_boss_stage2_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_ing_possession_data(self, asset_manager):
yield from self.ing_possession_data.dependencies_for(asset_manager)
def _dependencies_for_swamp_boss_stage2_data(self, asset_manager):
yield from self.swamp_boss_stage2_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_ing_possession_data, "ing_possession_data", "IngPossessionData"),
(self._dependencies_for_swamp_boss_stage2_data, "swamp_boss_stage2_data", "SwampBossStage2Data"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SwampBossStage2.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size, default_override={'mass': 25.0, 'turn_speed': 720.0, 'detection_range': 5.0, 'detection_height_range': 5.0, 'detection_angle': 90.0, 'min_attack_range': 4.0, 'max_attack_range': 20.0, 'damage_wait_time': 1.0, 'collision_radius': 0.5, 'collision_height': 1.5, 'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_ing_possession_data(data: typing.BinaryIO, property_size: int):
return IngPossessionData.from_stream(data, property_size)
def _decode_swamp_boss_stage2_data(data: typing.BinaryIO, property_size: int):
return SwampBossStage2Data.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),
0xe61748ed: ('ing_possession_data', _decode_ing_possession_data),
0xb31b771d: ('swamp_boss_stage2_data', _decode_swamp_boss_stage2_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SwampBossStage2.py | 0.585931 | 0.380299 | SwampBossStage2.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.GuiWidgetProperties import GuiWidgetProperties
@dataclasses.dataclass()
class GuiWidget(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
gui_widget_properties: GuiWidgetProperties = dataclasses.field(default_factory=GuiWidgetProperties)
controller_number: int = dataclasses.field(default=1)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GWIG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptGui.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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
num_properties_written = 2
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)
if self.controller_number != default_override.get('controller_number', 1):
num_properties_written += 1
data.write(b'\xdb\x7fJ\xa2') # 0xdb7f4aa2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.controller_number))
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']),
gui_widget_properties=GuiWidgetProperties.from_json(data['gui_widget_properties']),
controller_number=data['controller_number'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'gui_widget_properties': self.gui_widget_properties.to_json(),
'controller_number': self.controller_number,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_gui_widget_properties(self, asset_manager):
yield from self.gui_widget_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_gui_widget_properties, "gui_widget_properties", "GuiWidgetProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for GuiWidget.{field_name} ({field_type}): {e}"
)
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_controller_number(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),
0xdb7f4aa2: ('controller_number', _decode_controller_number),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/GuiWidget.py | 0.559531 | 0.29696 | GuiWidget.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
import retro_data_structures.enums.echoes as enums
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.ScannableParameters import ScannableParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanTreeInventory(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
name_string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
name_string_name: str = dataclasses.field(default='')
inventory_slot: enums.InventorySlot = dataclasses.field(default=enums.InventorySlot.PowerBeam)
scannable_parameters: ScannableParameters = dataclasses.field(default_factory=ScannableParameters)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SCIN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'F!\x9b\xac') # 0x46219bac
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.name_string_table))
data.write(b'2i\x8b\xd6') # 0x32698bd6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.name_string_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'=2o\x90') # 0x3d326f90
data.write(b'\x00\x04') # size
self.inventory_slot.to_stream(data)
data.write(b'-\xa1\xec3') # 0x2da1ec33
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scannable_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']),
name_string_table=data['name_string_table'],
name_string_name=data['name_string_name'],
inventory_slot=enums.InventorySlot.from_json(data['inventory_slot']),
scannable_parameters=ScannableParameters.from_json(data['scannable_parameters']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'name_string_table': self.name_string_table,
'name_string_name': self.name_string_name,
'inventory_slot': self.inventory_slot.to_json(),
'scannable_parameters': self.scannable_parameters.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_name_string_table(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.name_string_table)
def _dependencies_for_scannable_parameters(self, asset_manager):
yield from self.scannable_parameters.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_name_string_table, "name_string_table", "AssetId"),
(self._dependencies_for_scannable_parameters, "scannable_parameters", "ScannableParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScanTreeInventory.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_name_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_name_string_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_inventory_slot(data: typing.BinaryIO, property_size: int):
return enums.InventorySlot.from_stream(data)
def _decode_scannable_parameters(data: typing.BinaryIO, property_size: int):
return ScannableParameters.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),
0x46219bac: ('name_string_table', _decode_name_string_table),
0x32698bd6: ('name_string_name', _decode_name_string_name),
0x3d326f90: ('inventory_slot', _decode_inventory_slot),
0x2da1ec33: ('scannable_parameters', _decode_scannable_parameters),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ScanTreeInventory.py | 0.601125 | 0.315578 | ScanTreeInventory.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class Ripple(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
energy: float = dataclasses.field(default=-0.10000000149011612)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'RIPL'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'is\x1a\x91') # 0x69731a91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.energy))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
energy=data['energy'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'energy': self.energy,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Ripple.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_energy(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x69731a91: ('energy', _decode_energy),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Ripple.py | 0.655997 | 0.361221 | Ripple.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class FogVolume(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
fog_bob_height: float = dataclasses.field(default=0.0)
fog_bob_freq: float = dataclasses.field(default=1.0)
fog_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FOGV'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb9\r\xffD') # 0xb90dff44
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fog_bob_height))
data.write(b'\xf6\x08\xd3\\') # 0xf608d35c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fog_bob_freq))
data.write(b'\xe5x\xc0\xdd') # 0xe578c0dd
data.write(b'\x00\x10') # size
self.fog_color.to_stream(data)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
fog_bob_height=data['fog_bob_height'],
fog_bob_freq=data['fog_bob_freq'],
fog_color=Color.from_json(data['fog_color']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'fog_bob_height': self.fog_bob_height,
'fog_bob_freq': self.fog_bob_freq,
'fog_color': self.fog_color.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FogVolume.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_fog_bob_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fog_bob_freq(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fog_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb90dff44: ('fog_bob_height', _decode_fog_bob_height),
0xf608d35c: ('fog_bob_freq', _decode_fog_bob_freq),
0xe578c0dd: ('fog_color', _decode_fog_color),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/FogVolume.py | 0.658088 | 0.311518 | FogVolume.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class TweakSlideShow(BaseObjectType):
instance_name: str = dataclasses.field(default='')
pak_file: str = dataclasses.field(default='')
font: str = dataclasses.field(default='')
font_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
font_outline_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
unknown_0xd398dac2: float = dataclasses.field(default=50.0)
unknown_0x03757d08: float = dataclasses.field(default=50.0)
translation_multiplier: float = dataclasses.field(default=10.0)
scale_multiplier: float = dataclasses.field(default=10.0)
slide_show_delay: float = dataclasses.field(default=3.0)
help_frame_color: Color = dataclasses.field(default_factory=lambda: Color(r=0.0, g=0.0, b=0.0, a=0.0))
help_transition_time: float = dataclasses.field(default=1.0)
slide_blend_time: float = dataclasses.field(default=0.5)
unknown_0x029d2082: float = dataclasses.field(default=3.0)
unknown_0xb187cd9b: float = dataclasses.field(default=0.5)
fade_in_time: float = dataclasses.field(default=0.0010000000474974513)
fade_out_time: float = dataclasses.field(default=2.0)
unknown_0xc0544bc1: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWSS'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+\xd1:\xb3') # 0x2bd13ab3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.pak_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'\xfe1\xfb\xa0') # 0xfe31fba0
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.font.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'\x1a\x96\xecg') # 0x1a96ec67
data.write(b'\x00\x10') # size
self.font_color.to_stream(data)
data.write(b'\x84J\xb6\xb0') # 0x844ab6b0
data.write(b'\x00\x10') # size
self.font_outline_color.to_stream(data)
data.write(b'\xd3\x98\xda\xc2') # 0xd398dac2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd398dac2))
data.write(b'\x03u}\x08') # 0x3757d08
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x03757d08))
data.write(b"Y'n\x14") # 0x59276e14
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.translation_multiplier))
data.write(b'<\xe7\xa0\x13') # 0x3ce7a013
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scale_multiplier))
data.write(b"'\x8c\x08\x93") # 0x278c0893
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_show_delay))
data.write(b'\xd7])\xf8') # 0xd75d29f8
data.write(b'\x00\x10') # size
self.help_frame_color.to_stream(data)
data.write(b"'Q\\{") # 0x27515c7b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.help_transition_time))
data.write(b'\xaeG\xdc\x81') # 0xae47dc81
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.slide_blend_time))
data.write(b'\x02\x9d \x82') # 0x29d2082
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x029d2082))
data.write(b'\xb1\x87\xcd\x9b') # 0xb187cd9b
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xb187cd9b))
data.write(b'\x90\xaa4\x1f') # 0x90aa341f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_time))
data.write(b'|&\x9e\xbc') # 0x7c269ebc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_time))
data.write(b'\xc0TK\xc1') # 0xc0544bc1
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.unknown_0xc0544bc1.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(
instance_name=data['instance_name'],
pak_file=data['pak_file'],
font=data['font'],
font_color=Color.from_json(data['font_color']),
font_outline_color=Color.from_json(data['font_outline_color']),
unknown_0xd398dac2=data['unknown_0xd398dac2'],
unknown_0x03757d08=data['unknown_0x03757d08'],
translation_multiplier=data['translation_multiplier'],
scale_multiplier=data['scale_multiplier'],
slide_show_delay=data['slide_show_delay'],
help_frame_color=Color.from_json(data['help_frame_color']),
help_transition_time=data['help_transition_time'],
slide_blend_time=data['slide_blend_time'],
unknown_0x029d2082=data['unknown_0x029d2082'],
unknown_0xb187cd9b=data['unknown_0xb187cd9b'],
fade_in_time=data['fade_in_time'],
fade_out_time=data['fade_out_time'],
unknown_0xc0544bc1=data['unknown_0xc0544bc1'],
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'pak_file': self.pak_file,
'font': self.font,
'font_color': self.font_color.to_json(),
'font_outline_color': self.font_outline_color.to_json(),
'unknown_0xd398dac2': self.unknown_0xd398dac2,
'unknown_0x03757d08': self.unknown_0x03757d08,
'translation_multiplier': self.translation_multiplier,
'scale_multiplier': self.scale_multiplier,
'slide_show_delay': self.slide_show_delay,
'help_frame_color': self.help_frame_color.to_json(),
'help_transition_time': self.help_transition_time,
'slide_blend_time': self.slide_blend_time,
'unknown_0x029d2082': self.unknown_0x029d2082,
'unknown_0xb187cd9b': self.unknown_0xb187cd9b,
'fade_in_time': self.fade_in_time,
'fade_out_time': self.fade_out_time,
'unknown_0xc0544bc1': self.unknown_0xc0544bc1,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_pak_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_font(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_font_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_font_outline_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_unknown_0xd398dac2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x03757d08(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_translation_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_scale_multiplier(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_show_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_help_frame_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_help_transition_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_slide_blend_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x029d2082(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xb187cd9b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xc0544bc1(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]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0x2bd13ab3: ('pak_file', _decode_pak_file),
0xfe31fba0: ('font', _decode_font),
0x1a96ec67: ('font_color', _decode_font_color),
0x844ab6b0: ('font_outline_color', _decode_font_outline_color),
0xd398dac2: ('unknown_0xd398dac2', _decode_unknown_0xd398dac2),
0x3757d08: ('unknown_0x03757d08', _decode_unknown_0x03757d08),
0x59276e14: ('translation_multiplier', _decode_translation_multiplier),
0x3ce7a013: ('scale_multiplier', _decode_scale_multiplier),
0x278c0893: ('slide_show_delay', _decode_slide_show_delay),
0xd75d29f8: ('help_frame_color', _decode_help_frame_color),
0x27515c7b: ('help_transition_time', _decode_help_transition_time),
0xae47dc81: ('slide_blend_time', _decode_slide_blend_time),
0x29d2082: ('unknown_0x029d2082', _decode_unknown_0x029d2082),
0xb187cd9b: ('unknown_0xb187cd9b', _decode_unknown_0xb187cd9b),
0x90aa341f: ('fade_in_time', _decode_fade_in_time),
0x7c269ebc: ('fade_out_time', _decode_fade_out_time),
0xc0544bc1: ('unknown_0xc0544bc1', _decode_unknown_0xc0544bc1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakSlideShow.py | 0.581541 | 0.289547 | TweakSlideShow.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
@dataclasses.dataclass()
class SnakeWeedSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
density: float = dataclasses.field(default=1.0)
max_depth: float = dataclasses.field(default=1.0)
location_variance: float = dataclasses.field(default=0.5)
detection_radius: float = dataclasses.field(default=4.0)
grab_radius: float = dataclasses.field(default=1.0)
unknown_0x723737bc: float = dataclasses.field(default=2.0)
unknown_0x57452dd9: float = dataclasses.field(default=0.20000000298023224)
retreat_depth: float = dataclasses.field(default=2.5)
move_speed: float = dataclasses.field(default=1.5)
unknown_0x11f854e2: float = dataclasses.field(default=3.0)
max_slope: float = dataclasses.field(default=5.0)
min_size: float = dataclasses.field(default=1.0)
max_size: float = dataclasses.field(default=1.0)
height_offset: float = dataclasses.field(default=0.0)
contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
damage_wait_time: float = dataclasses.field(default=0.0)
sound_looped: int = dataclasses.field(default=0, metadata={'sound': True})
sound_into_ground: int = dataclasses.field(default=0, metadata={'sound': True})
sound_outof_ground: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SNAK'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SnakeWeedSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x16') # 22 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'd\xe5\xfe\x9f') # 0x64e5fe9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.density))
data.write(b'#\xce\xf9_') # 0x23cef95f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_depth))
data.write(b'\xbe\x02\xe4V') # 0xbe02e456
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.location_variance))
data.write(b'!\xcd\xcf!') # 0x21cdcf21
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.detection_radius))
data.write(b'\x89fG#') # 0x89664723
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.grab_radius))
data.write(b'r77\xbc') # 0x723737bc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x723737bc))
data.write(b'WE-\xd9') # 0x57452dd9
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x57452dd9))
data.write(b'\\ \xb0\xc7') # 0x5c20b0c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.retreat_depth))
data.write(b'd\x97\xc7P') # 0x6497c750
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.move_speed))
data.write(b'\x11\xf8T\xe2') # 0x11f854e2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x11f854e2))
data.write(b'\xa7U\xc1\xdf') # 0xa755c1df
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_slope))
data.write(b'U\x8cm\xd7') # 0x558c6dd7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.min_size))
data.write(b'\xc5\xff}=') # 0xc5ff7d3d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_size))
data.write(b'\xb2\xeb\xc2:') # 0xb2ebc23a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.height_offset))
data.write(b'\xd7VAn') # 0xd756416e
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.contact_damage.to_stream(data, default_override={'di_weapon_type': 9})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe0\xcd\xc7\xe3') # 0xe0cdc7e3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_wait_time))
data.write(b'\xcd}\x99n') # 0xcd7d996e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_looped))
data.write(b'\x10&\xdb\x89') # 0x1026db89
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_into_ground))
data.write(b'\xcd\xe1sF') # 0xcde17346
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_outof_ground))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_information=AnimationParameters.from_json(data['animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
density=data['density'],
max_depth=data['max_depth'],
location_variance=data['location_variance'],
detection_radius=data['detection_radius'],
grab_radius=data['grab_radius'],
unknown_0x723737bc=data['unknown_0x723737bc'],
unknown_0x57452dd9=data['unknown_0x57452dd9'],
retreat_depth=data['retreat_depth'],
move_speed=data['move_speed'],
unknown_0x11f854e2=data['unknown_0x11f854e2'],
max_slope=data['max_slope'],
min_size=data['min_size'],
max_size=data['max_size'],
height_offset=data['height_offset'],
contact_damage=DamageInfo.from_json(data['contact_damage']),
damage_wait_time=data['damage_wait_time'],
sound_looped=data['sound_looped'],
sound_into_ground=data['sound_into_ground'],
sound_outof_ground=data['sound_outof_ground'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'animation_information': self.animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'density': self.density,
'max_depth': self.max_depth,
'location_variance': self.location_variance,
'detection_radius': self.detection_radius,
'grab_radius': self.grab_radius,
'unknown_0x723737bc': self.unknown_0x723737bc,
'unknown_0x57452dd9': self.unknown_0x57452dd9,
'retreat_depth': self.retreat_depth,
'move_speed': self.move_speed,
'unknown_0x11f854e2': self.unknown_0x11f854e2,
'max_slope': self.max_slope,
'min_size': self.min_size,
'max_size': self.max_size,
'height_offset': self.height_offset,
'contact_damage': self.contact_damage.to_json(),
'damage_wait_time': self.damage_wait_time,
'sound_looped': self.sound_looped,
'sound_into_ground': self.sound_into_ground,
'sound_outof_ground': self.sound_outof_ground,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_contact_damage(self, asset_manager):
yield from self.contact_damage.dependencies_for(asset_manager)
def _dependencies_for_sound_looped(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_looped)
def _dependencies_for_sound_into_ground(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_into_ground)
def _dependencies_for_sound_outof_ground(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_outof_ground)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_contact_damage, "contact_damage", "DamageInfo"),
(self._dependencies_for_sound_looped, "sound_looped", "int"),
(self._dependencies_for_sound_into_ground, "sound_into_ground", "int"),
(self._dependencies_for_sound_outof_ground, "sound_outof_ground", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SnakeWeedSwarm.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_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_density(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_depth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_location_variance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_detection_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_grab_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x723737bc(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x57452dd9(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_retreat_depth(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_move_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x11f854e2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_slope(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_min_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_size(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_height_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_contact_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 9})
def _decode_damage_wait_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_sound_looped(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_into_ground(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound_outof_ground(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),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0x64e5fe9f: ('density', _decode_density),
0x23cef95f: ('max_depth', _decode_max_depth),
0xbe02e456: ('location_variance', _decode_location_variance),
0x21cdcf21: ('detection_radius', _decode_detection_radius),
0x89664723: ('grab_radius', _decode_grab_radius),
0x723737bc: ('unknown_0x723737bc', _decode_unknown_0x723737bc),
0x57452dd9: ('unknown_0x57452dd9', _decode_unknown_0x57452dd9),
0x5c20b0c7: ('retreat_depth', _decode_retreat_depth),
0x6497c750: ('move_speed', _decode_move_speed),
0x11f854e2: ('unknown_0x11f854e2', _decode_unknown_0x11f854e2),
0xa755c1df: ('max_slope', _decode_max_slope),
0x558c6dd7: ('min_size', _decode_min_size),
0xc5ff7d3d: ('max_size', _decode_max_size),
0xb2ebc23a: ('height_offset', _decode_height_offset),
0xd756416e: ('contact_damage', _decode_contact_damage),
0xe0cdc7e3: ('damage_wait_time', _decode_damage_wait_time),
0xcd7d996e: ('sound_looped', _decode_sound_looped),
0x1026db89: ('sound_into_ground', _decode_sound_into_ground),
0xcde17346: ('sound_outof_ground', _decode_sound_outof_ground),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SnakeWeedSwarm.py | 0.610453 | 0.29054 | SnakeWeedSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SpiderBallWaypoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BALW'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b']\x81t\x83') # 0x5d817483
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags=data['flags'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags': self.flags,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpiderBallWaypoint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x5d817483: ('flags', _decode_flags),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SpiderBallWaypoint.py | 0.585457 | 0.353651 | SpiderBallWaypoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class PillBug(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
unknown_0xde7e9f94: int = dataclasses.field(default=0)
floor_turn_speed: float = dataclasses.field(default=120.0)
stick_radius: float = dataclasses.field(default=0.20000000298023224)
waypoint_approach_distance: float = dataclasses.field(default=1.5)
visible_distance: float = dataclasses.field(default=200.0)
damage_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
wander_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
crawl_radius: float = dataclasses.field(default=0.3499999940395355)
roll_radius: float = dataclasses.field(default=0.5)
unknown_0x519c7197: float = dataclasses.field(default=0.5)
unknown_0xa265383c: float = dataclasses.field(default=0.019999999552965164)
forward_priority: float = dataclasses.field(default=0.30000001192092896)
unknown_0x558c0692: float = dataclasses.field(default=0.6000000238418579)
unknown_0x0f991bf1: float = dataclasses.field(default=1.5)
unknown_0x385a1bed: float = dataclasses.field(default=0.6000000238418579)
unknown_0xcf4ea141: float = dataclasses.field(default=1.5)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PILB'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'PillBug.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\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'\xde~\x9f\x94') # 0xde7e9f94
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xde7e9f94))
data.write(b'\x8eO{)') # 0x8e4f7b29
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.floor_turn_speed))
data.write(b'Z:0\xf4') # 0x5a3a30f4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.stick_radius))
data.write(b's;\xd2|') # 0x733bd27c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.waypoint_approach_distance))
data.write(b'\xa7%0\xe8') # 0xa72530e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_distance))
data.write(b']\x84\xedq') # 0x5d84ed71
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf3\x82\xdf\xf7') # 0xf382dff7
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.wander_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xad\x98\xe1m') # 0xad98e16d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.crawl_radius))
data.write(b'\x81\xd6\x99\xb0') # 0x81d699b0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.roll_radius))
data.write(b'Q\x9cq\x97') # 0x519c7197
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x519c7197))
data.write(b'\xa2e8<') # 0xa265383c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa265383c))
data.write(b'\xad\x08\xe1\x89') # 0xad08e189
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_priority))
data.write(b'U\x8c\x06\x92') # 0x558c0692
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x558c0692))
data.write(b'\x0f\x99\x1b\xf1') # 0xf991bf1
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x0f991bf1))
data.write(b'8Z\x1b\xed') # 0x385a1bed
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x385a1bed))
data.write(b'\xcfN\xa1A') # 0xcf4ea141
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xcf4ea141))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_0xde7e9f94=data['unknown_0xde7e9f94'],
floor_turn_speed=data['floor_turn_speed'],
stick_radius=data['stick_radius'],
waypoint_approach_distance=data['waypoint_approach_distance'],
visible_distance=data['visible_distance'],
damage_vulnerability=DamageVulnerability.from_json(data['damage_vulnerability']),
wander_vulnerability=DamageVulnerability.from_json(data['wander_vulnerability']),
crawl_radius=data['crawl_radius'],
roll_radius=data['roll_radius'],
unknown_0x519c7197=data['unknown_0x519c7197'],
unknown_0xa265383c=data['unknown_0xa265383c'],
forward_priority=data['forward_priority'],
unknown_0x558c0692=data['unknown_0x558c0692'],
unknown_0x0f991bf1=data['unknown_0x0f991bf1'],
unknown_0x385a1bed=data['unknown_0x385a1bed'],
unknown_0xcf4ea141=data['unknown_0xcf4ea141'],
)
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_0xde7e9f94': self.unknown_0xde7e9f94,
'floor_turn_speed': self.floor_turn_speed,
'stick_radius': self.stick_radius,
'waypoint_approach_distance': self.waypoint_approach_distance,
'visible_distance': self.visible_distance,
'damage_vulnerability': self.damage_vulnerability.to_json(),
'wander_vulnerability': self.wander_vulnerability.to_json(),
'crawl_radius': self.crawl_radius,
'roll_radius': self.roll_radius,
'unknown_0x519c7197': self.unknown_0x519c7197,
'unknown_0xa265383c': self.unknown_0xa265383c,
'forward_priority': self.forward_priority,
'unknown_0x558c0692': self.unknown_0x558c0692,
'unknown_0x0f991bf1': self.unknown_0x0f991bf1,
'unknown_0x385a1bed': self.unknown_0x385a1bed,
'unknown_0xcf4ea141': self.unknown_0xcf4ea141,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_damage_vulnerability(self, asset_manager):
yield from self.damage_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_wander_vulnerability(self, asset_manager):
yield from self.wander_vulnerability.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_damage_vulnerability, "damage_vulnerability", "DamageVulnerability"),
(self._dependencies_for_wander_vulnerability, "wander_vulnerability", "DamageVulnerability"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PillBug.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_0xde7e9f94(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', 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_stick_radius(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_visible_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_wander_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_crawl_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_roll_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x519c7197(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xa265383c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_forward_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x558c0692(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x0f991bf1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x385a1bed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xcf4ea141(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xde7e9f94: ('unknown_0xde7e9f94', _decode_unknown_0xde7e9f94),
0x8e4f7b29: ('floor_turn_speed', _decode_floor_turn_speed),
0x5a3a30f4: ('stick_radius', _decode_stick_radius),
0x733bd27c: ('waypoint_approach_distance', _decode_waypoint_approach_distance),
0xa72530e8: ('visible_distance', _decode_visible_distance),
0x5d84ed71: ('damage_vulnerability', _decode_damage_vulnerability),
0xf382dff7: ('wander_vulnerability', _decode_wander_vulnerability),
0xad98e16d: ('crawl_radius', _decode_crawl_radius),
0x81d699b0: ('roll_radius', _decode_roll_radius),
0x519c7197: ('unknown_0x519c7197', _decode_unknown_0x519c7197),
0xa265383c: ('unknown_0xa265383c', _decode_unknown_0xa265383c),
0xad08e189: ('forward_priority', _decode_forward_priority),
0x558c0692: ('unknown_0x558c0692', _decode_unknown_0x558c0692),
0xf991bf1: ('unknown_0x0f991bf1', _decode_unknown_0x0f991bf1),
0x385a1bed: ('unknown_0x385a1bed', _decode_unknown_0x385a1bed),
0xcf4ea141: ('unknown_0xcf4ea141', _decode_unknown_0xcf4ea141),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PillBug.py | 0.583915 | 0.306994 | PillBug.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.ScannableParameters import ScannableParameters
@dataclasses.dataclass()
class PointOfInterest(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
scan_info: ScannableParameters = dataclasses.field(default_factory=ScannableParameters)
scan_offset: float = dataclasses.field(default=1.5)
look_at_poi: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'POIN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xbd\xbe\xc2\x95') # 0xbdbec295
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.scan_info.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b"\x87'\x162") # 0x87271632
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scan_offset))
data.write(b'\x01\xf9\xc5\xbb') # 0x1f9c5bb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.look_at_poi))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
scan_info=ScannableParameters.from_json(data['scan_info']),
scan_offset=data['scan_offset'],
look_at_poi=data['look_at_poi'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'scan_info': self.scan_info.to_json(),
'scan_offset': self.scan_offset,
'look_at_poi': self.look_at_poi,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_scan_info(self, asset_manager):
yield from self.scan_info.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_scan_info, "scan_info", "ScannableParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PointOfInterest.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_scan_info(data: typing.BinaryIO, property_size: int):
return ScannableParameters.from_stream(data, property_size)
def _decode_scan_offset(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_at_poi(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xbdbec295: ('scan_info', _decode_scan_info),
0x87271632: ('scan_offset', _decode_scan_offset),
0x1f9c5bb: ('look_at_poi', _decode_look_at_poi),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PointOfInterest.py | 0.601242 | 0.341047 | PointOfInterest.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.SplitterMainChassisData import SplitterMainChassisData
@dataclasses.dataclass()
class SplitterMainChassis(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
splitter_main_chassis_data: SplitterMainChassisData = dataclasses.field(default_factory=SplitterMainChassisData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPLL'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Splitter.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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': 60.0, 'min_attack_range': 12.0, 'max_attack_range': 37.0, 'creature_size': 2})
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'\x15\xe0:/') # 0x15e03a2f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.splitter_main_chassis_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']),
splitter_main_chassis_data=SplitterMainChassisData.from_json(data['splitter_main_chassis_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(),
'splitter_main_chassis_data': self.splitter_main_chassis_data.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_splitter_main_chassis_data(self, asset_manager):
yield from self.splitter_main_chassis_data.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_splitter_main_chassis_data, "splitter_main_chassis_data", "SplitterMainChassisData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SplitterMainChassis.{field_name} ({field_type}): {e}"
)
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': 60.0, 'min_attack_range': 12.0, 'max_attack_range': 37.0, 'creature_size': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_splitter_main_chassis_data(data: typing.BinaryIO, property_size: int):
return SplitterMainChassisData.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),
0x15e03a2f: ('splitter_main_chassis_data', _decode_splitter_main_chassis_data),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SplitterMainChassis.py | 0.62223 | 0.307995 | SplitterMainChassis.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct33 import UnknownStruct33
from retro_data_structures.properties.echoes.archetypes.UnknownStruct34 import UnknownStruct34
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class MinorIng(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
projectile_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
unknown_0xa03e450c: float = dataclasses.field(default=20.0)
attack_angle_limit: float = dataclasses.field(default=90.0)
unknown_0x99bb2559: float = dataclasses.field(default=2.0)
unknown_0xd6c8eac2: float = dataclasses.field(default=7.0)
unknown_0x2a5449ba: float = dataclasses.field(default=7.0)
hearing_radius: float = dataclasses.field(default=50.0)
unknown_0x399d1eaa: bool = dataclasses.field(default=False)
unknown_0xbce16644: bool = dataclasses.field(default=False)
unknown_0x142433d3: bool = dataclasses.field(default=False)
unknown_0xb6cc0063: bool = dataclasses.field(default=False)
unknown_0xe601f7bd: bool = dataclasses.field(default=False)
unknown_0x09207f51: bool = dataclasses.field(default=False)
unknown_0x2107e4fb: bool = dataclasses.field(default=False)
unknown_struct33: UnknownStruct33 = dataclasses.field(default_factory=UnknownStruct33)
unknown_struct34: UnknownStruct34 = dataclasses.field(default_factory=UnknownStruct34)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MNNG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['GeomBlobV2.rel', 'MinorIng.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x14') # 20 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'min_attack_range': 4.5, 'max_attack_range': 30.0, 'average_attack_time': 3.0, 'collision_height': 4.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'U;\x139') # 0x553b1339
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.projectile_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 5.0, 'di_knock_back_power': 3.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xefH]\xb9') # 0xef485db9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile))
data.write(b'\xa0>E\x0c') # 0xa03e450c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xa03e450c))
data.write(b'{\x9a\x0b\xb4') # 0x7b9a0bb4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_angle_limit))
data.write(b'\x99\xbb%Y') # 0x99bb2559
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x99bb2559))
data.write(b'\xd6\xc8\xea\xc2') # 0xd6c8eac2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xd6c8eac2))
data.write(b'*TI\xba') # 0x2a5449ba
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2a5449ba))
data.write(b'\xediH\x8f') # 0xed69488f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hearing_radius))
data.write(b'9\x9d\x1e\xaa') # 0x399d1eaa
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x399d1eaa))
data.write(b'\xbc\xe1fD') # 0xbce16644
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbce16644))
data.write(b'\x14$3\xd3') # 0x142433d3
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x142433d3))
data.write(b'\xb6\xcc\x00c') # 0xb6cc0063
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xb6cc0063))
data.write(b'\xe6\x01\xf7\xbd') # 0xe601f7bd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xe601f7bd))
data.write(b'\t \x7fQ') # 0x9207f51
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x09207f51))
data.write(b'!\x07\xe4\xfb') # 0x2107e4fb
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x2107e4fb))
data.write(b'\x07\xe9\xd4F') # 0x7e9d446
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct33.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'=\xa3XQ') # 0x3da35851
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct34.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
projectile_damage=DamageInfo.from_json(data['projectile_damage']),
projectile=data['projectile'],
unknown_0xa03e450c=data['unknown_0xa03e450c'],
attack_angle_limit=data['attack_angle_limit'],
unknown_0x99bb2559=data['unknown_0x99bb2559'],
unknown_0xd6c8eac2=data['unknown_0xd6c8eac2'],
unknown_0x2a5449ba=data['unknown_0x2a5449ba'],
hearing_radius=data['hearing_radius'],
unknown_0x399d1eaa=data['unknown_0x399d1eaa'],
unknown_0xbce16644=data['unknown_0xbce16644'],
unknown_0x142433d3=data['unknown_0x142433d3'],
unknown_0xb6cc0063=data['unknown_0xb6cc0063'],
unknown_0xe601f7bd=data['unknown_0xe601f7bd'],
unknown_0x09207f51=data['unknown_0x09207f51'],
unknown_0x2107e4fb=data['unknown_0x2107e4fb'],
unknown_struct33=UnknownStruct33.from_json(data['unknown_struct33']),
unknown_struct34=UnknownStruct34.from_json(data['unknown_struct34']),
)
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(),
'projectile_damage': self.projectile_damage.to_json(),
'projectile': self.projectile,
'unknown_0xa03e450c': self.unknown_0xa03e450c,
'attack_angle_limit': self.attack_angle_limit,
'unknown_0x99bb2559': self.unknown_0x99bb2559,
'unknown_0xd6c8eac2': self.unknown_0xd6c8eac2,
'unknown_0x2a5449ba': self.unknown_0x2a5449ba,
'hearing_radius': self.hearing_radius,
'unknown_0x399d1eaa': self.unknown_0x399d1eaa,
'unknown_0xbce16644': self.unknown_0xbce16644,
'unknown_0x142433d3': self.unknown_0x142433d3,
'unknown_0xb6cc0063': self.unknown_0xb6cc0063,
'unknown_0xe601f7bd': self.unknown_0xe601f7bd,
'unknown_0x09207f51': self.unknown_0x09207f51,
'unknown_0x2107e4fb': self.unknown_0x2107e4fb,
'unknown_struct33': self.unknown_struct33.to_json(),
'unknown_struct34': self.unknown_struct34.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_projectile_damage(self, asset_manager):
yield from self.projectile_damage.dependencies_for(asset_manager)
def _dependencies_for_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile)
def _dependencies_for_unknown_struct33(self, asset_manager):
yield from self.unknown_struct33.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct34(self, asset_manager):
yield from self.unknown_struct34.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_projectile_damage, "projectile_damage", "DamageInfo"),
(self._dependencies_for_projectile, "projectile", "AssetId"),
(self._dependencies_for_unknown_struct33, "unknown_struct33", "UnknownStruct33"),
(self._dependencies_for_unknown_struct34, "unknown_struct34", "UnknownStruct34"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MinorIng.{field_name} ({field_type}): {e}"
)
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={'min_attack_range': 4.5, 'max_attack_range': 30.0, 'average_attack_time': 3.0, 'collision_height': 4.0})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_projectile_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0, 'di_knock_back_power': 3.0})
def _decode_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xa03e450c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_angle_limit(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x99bb2559(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xd6c8eac2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2a5449ba(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_hearing_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x399d1eaa(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbce16644(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x142433d3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xb6cc0063(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xe601f7bd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x09207f51(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x2107e4fb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_struct33(data: typing.BinaryIO, property_size: int):
return UnknownStruct33.from_stream(data, property_size)
def _decode_unknown_struct34(data: typing.BinaryIO, property_size: int):
return UnknownStruct34.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),
0x553b1339: ('projectile_damage', _decode_projectile_damage),
0xef485db9: ('projectile', _decode_projectile),
0xa03e450c: ('unknown_0xa03e450c', _decode_unknown_0xa03e450c),
0x7b9a0bb4: ('attack_angle_limit', _decode_attack_angle_limit),
0x99bb2559: ('unknown_0x99bb2559', _decode_unknown_0x99bb2559),
0xd6c8eac2: ('unknown_0xd6c8eac2', _decode_unknown_0xd6c8eac2),
0x2a5449ba: ('unknown_0x2a5449ba', _decode_unknown_0x2a5449ba),
0xed69488f: ('hearing_radius', _decode_hearing_radius),
0x399d1eaa: ('unknown_0x399d1eaa', _decode_unknown_0x399d1eaa),
0xbce16644: ('unknown_0xbce16644', _decode_unknown_0xbce16644),
0x142433d3: ('unknown_0x142433d3', _decode_unknown_0x142433d3),
0xb6cc0063: ('unknown_0xb6cc0063', _decode_unknown_0xb6cc0063),
0xe601f7bd: ('unknown_0xe601f7bd', _decode_unknown_0xe601f7bd),
0x9207f51: ('unknown_0x09207f51', _decode_unknown_0x09207f51),
0x2107e4fb: ('unknown_0x2107e4fb', _decode_unknown_0x2107e4fb),
0x7e9d446: ('unknown_struct33', _decode_unknown_struct33),
0x3da35851: ('unknown_struct34', _decode_unknown_struct34),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/MinorIng.py | 0.557123 | 0.272396 | MinorIng.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TargetingPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TGPT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x01') # 1 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data, default_override={'active': False})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TargetingPoint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TargetingPoint.py | 0.620277 | 0.357343 | TargetingPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ScanTreeCategory(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
name_string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
name_string_name: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SCND'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'F!\x9b\xac') # 0x46219bac
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.name_string_table))
data.write(b'2i\x8b\xd6') # 0x32698bd6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.name_string_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']),
name_string_table=data['name_string_table'],
name_string_name=data['name_string_name'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'name_string_table': self.name_string_table,
'name_string_name': self.name_string_name,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_name_string_table(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.name_string_table)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_name_string_table, "name_string_table", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ScanTreeCategory.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_name_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_name_string_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),
0x46219bac: ('name_string_table', _decode_name_string_table),
0x32698bd6: ('name_string_name', _decode_name_string_name),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ScanTreeCategory.py | 0.561095 | 0.304009 | ScanTreeCategory.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.SpawnPointStruct import SpawnPointStruct
@dataclasses.dataclass()
class SpawnPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
first_spawn: bool = dataclasses.field(default=True)
morphed: bool = dataclasses.field(default=False)
amount: SpawnPointStruct = dataclasses.field(default_factory=SpawnPointStruct)
capacity: SpawnPointStruct = dataclasses.field(default_factory=SpawnPointStruct)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPWN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\xc0\xe4R\x1b') # 0xc0e4521b
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.first_spawn))
data.write(b'\xb9\xc4\x0f\x92') # 0xb9c40f92
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.morphed))
data.write(b'L\x1dL\xc9') # 0x4c1d4cc9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.amount.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'@\x81\xbf\x95') # 0x4081bf95
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.capacity.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
first_spawn=data['first_spawn'],
morphed=data['morphed'],
amount=SpawnPointStruct.from_json(data['amount']),
capacity=SpawnPointStruct.from_json(data['capacity']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'first_spawn': self.first_spawn,
'morphed': self.morphed,
'amount': self.amount.to_json(),
'capacity': self.capacity.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_amount(self, asset_manager):
yield from self.amount.dependencies_for(asset_manager)
def _dependencies_for_capacity(self, asset_manager):
yield from self.capacity.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_amount, "amount", "SpawnPointStruct"),
(self._dependencies_for_capacity, "capacity", "SpawnPointStruct"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpawnPoint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_first_spawn(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_morphed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_amount(data: typing.BinaryIO, property_size: int):
return SpawnPointStruct.from_stream(data, property_size)
def _decode_capacity(data: typing.BinaryIO, property_size: int):
return SpawnPointStruct.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc0e4521b: ('first_spawn', _decode_first_spawn),
0xb9c40f92: ('morphed', _decode_morphed),
0x4c1d4cc9: ('amount', _decode_amount),
0x4081bf95: ('capacity', _decode_capacity),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SpawnPoint.py | 0.586404 | 0.361982 | SpawnPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class TimeKeyframe(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
time: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'TKEY'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x02') # 2 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D3Z\xff') # 0x44335aff
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.time))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
time=data['time'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'time': self.time,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TimeKeyframe.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x44335aff: ('time', _decode_time),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TimeKeyframe.py | 0.620622 | 0.362885 | TimeKeyframe.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.TweakAutoMapper.Base import Base
from retro_data_structures.properties.echoes.archetypes.TweakAutoMapper.DoorColors import DoorColors
@dataclasses.dataclass()
class TweakAutoMapper(BaseObjectType):
instance_name: str = dataclasses.field(default='')
base: Base = dataclasses.field(default_factory=Base)
door_colors: DoorColors = dataclasses.field(default_factory=DoorColors)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWAM'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x18\xb2\xf4#') # 0x18b2f423
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.base.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc56\x88c') # 0xc5368863
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.door_colors.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(
instance_name=data['instance_name'],
base=Base.from_json(data['base']),
door_colors=DoorColors.from_json(data['door_colors']),
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'base': self.base.to_json(),
'door_colors': self.door_colors.to_json(),
}
def _dependencies_for_base(self, asset_manager):
yield from self.base.dependencies_for(asset_manager)
def _dependencies_for_door_colors(self, asset_manager):
yield from self.door_colors.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_base, "base", "Base"),
(self._dependencies_for_door_colors, "door_colors", "DoorColors"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for TweakAutoMapper.{field_name} ({field_type}): {e}"
)
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_base(data: typing.BinaryIO, property_size: int):
return Base.from_stream(data, property_size)
def _decode_door_colors(data: typing.BinaryIO, property_size: int):
return DoorColors.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0x18b2f423: ('base', _decode_base),
0xc5368863: ('door_colors', _decode_door_colors),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakAutoMapper.py | 0.620162 | 0.299272 | TweakAutoMapper.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.FlareDef import FlareDef
@dataclasses.dataclass()
class VisorFlare(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
blend_mode: int = dataclasses.field(default=0)
constant_scale: bool = dataclasses.field(default=True)
fade_time: float = dataclasses.field(default=0.10000000149011612)
fade_factor: float = dataclasses.field(default=1.0)
rotate_factor: float = dataclasses.field(default=2.0)
combat_visor_mode: int = dataclasses.field(default=0)
unknown: bool = dataclasses.field(default=True)
no_occlusion_test: bool = dataclasses.field(default=False)
flare1: FlareDef = dataclasses.field(default_factory=FlareDef)
flare2: FlareDef = dataclasses.field(default_factory=FlareDef)
flare3: FlareDef = dataclasses.field(default_factory=FlareDef)
flare4: FlareDef = dataclasses.field(default_factory=FlareDef)
flare5: FlareDef = dataclasses.field(default_factory=FlareDef)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FLAR'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x0e') # 14 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xcb\x13\xefF') # 0xcb13ef46
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.blend_mode))
data.write(b'\xe0\xc5\xfc\x06') # 0xe0c5fc06
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.constant_scale))
data.write(b'\xd4\x12LL') # 0xd4124c4c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_time))
data.write(b'\xd6\xfb1\xbf') # 0xd6fb31bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_factor))
data.write(b'1a\xf3\x8c') # 0x3161f38c
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.rotate_factor))
data.write(b'C\xb5\x03\xa6') # 0x43b503a6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.combat_visor_mode))
data.write(b'\xa5\x1f$>') # 0xa51f243e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
data.write(b'\x05\x08\x81\xa9') # 0x50881a9
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.no_occlusion_test))
data.write(b'<%r#') # 0x3c257223
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare1.to_stream(data, default_override={'scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x05\xa8N\xe6') # 0x5a84ee6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare2.to_stream(data, default_override={'position': 0.25, 'scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x12\xd3Z\xa5') # 0x12d35aa5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare3.to_stream(data, default_override={'position': 0.5, 'scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'v\xb27l') # 0x76b2376c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare4.to_stream(data, default_override={'position': 0.75, 'scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'a\xc9#/') # 0x61c9232f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.flare5.to_stream(data, default_override={'position': 1.0, 'scale': 1.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
blend_mode=data['blend_mode'],
constant_scale=data['constant_scale'],
fade_time=data['fade_time'],
fade_factor=data['fade_factor'],
rotate_factor=data['rotate_factor'],
combat_visor_mode=data['combat_visor_mode'],
unknown=data['unknown'],
no_occlusion_test=data['no_occlusion_test'],
flare1=FlareDef.from_json(data['flare1']),
flare2=FlareDef.from_json(data['flare2']),
flare3=FlareDef.from_json(data['flare3']),
flare4=FlareDef.from_json(data['flare4']),
flare5=FlareDef.from_json(data['flare5']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'blend_mode': self.blend_mode,
'constant_scale': self.constant_scale,
'fade_time': self.fade_time,
'fade_factor': self.fade_factor,
'rotate_factor': self.rotate_factor,
'combat_visor_mode': self.combat_visor_mode,
'unknown': self.unknown,
'no_occlusion_test': self.no_occlusion_test,
'flare1': self.flare1.to_json(),
'flare2': self.flare2.to_json(),
'flare3': self.flare3.to_json(),
'flare4': self.flare4.to_json(),
'flare5': self.flare5.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_flare1(self, asset_manager):
yield from self.flare1.dependencies_for(asset_manager)
def _dependencies_for_flare2(self, asset_manager):
yield from self.flare2.dependencies_for(asset_manager)
def _dependencies_for_flare3(self, asset_manager):
yield from self.flare3.dependencies_for(asset_manager)
def _dependencies_for_flare4(self, asset_manager):
yield from self.flare4.dependencies_for(asset_manager)
def _dependencies_for_flare5(self, asset_manager):
yield from self.flare5.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_flare1, "flare1", "FlareDef"),
(self._dependencies_for_flare2, "flare2", "FlareDef"),
(self._dependencies_for_flare3, "flare3", "FlareDef"),
(self._dependencies_for_flare4, "flare4", "FlareDef"),
(self._dependencies_for_flare5, "flare5", "FlareDef"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for VisorFlare.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_blend_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_constant_scale(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fade_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_rotate_factor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_combat_visor_mode(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_no_occlusion_test(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_flare1(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'scale': 1.0})
def _decode_flare2(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 0.25, 'scale': 1.0})
def _decode_flare3(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 0.5, 'scale': 1.0})
def _decode_flare4(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 0.75, 'scale': 1.0})
def _decode_flare5(data: typing.BinaryIO, property_size: int):
return FlareDef.from_stream(data, property_size, default_override={'position': 1.0, 'scale': 1.0})
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xcb13ef46: ('blend_mode', _decode_blend_mode),
0xe0c5fc06: ('constant_scale', _decode_constant_scale),
0xd4124c4c: ('fade_time', _decode_fade_time),
0xd6fb31bf: ('fade_factor', _decode_fade_factor),
0x3161f38c: ('rotate_factor', _decode_rotate_factor),
0x43b503a6: ('combat_visor_mode', _decode_combat_visor_mode),
0xa51f243e: ('unknown', _decode_unknown),
0x50881a9: ('no_occlusion_test', _decode_no_occlusion_test),
0x3c257223: ('flare1', _decode_flare1),
0x5a84ee6: ('flare2', _decode_flare2),
0x12d35aa5: ('flare3', _decode_flare3),
0x76b2376c: ('flare4', _decode_flare4),
0x61c9232f: ('flare5', _decode_flare5),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/VisorFlare.py | 0.503418 | 0.357764 | VisorFlare.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class GuiScreen(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
which_screen: int = dataclasses.field(default=0)
string_table: AssetId = dataclasses.field(metadata={'asset_types': ['STRG']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'GSCR'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptGui.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x03') # 3 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xd3\xb7\xe6\xd8') # 0xd3b7e6d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.which_screen))
data.write(b'\xfd\x95\xed*') # 0xfd95ed2a
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.string_table))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
which_screen=data['which_screen'],
string_table=data['string_table'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'which_screen': self.which_screen,
'string_table': self.string_table,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_string_table(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.string_table)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_string_table, "string_table", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for GuiScreen.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_which_screen(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_string_table(data: typing.BinaryIO, property_size: int):
return struct.unpack(">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),
0xd3b7e6d8: ('which_screen', _decode_which_screen),
0xfd95ed2a: ('string_table', _decode_string_table),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/GuiScreen.py | 0.566019 | 0.312462 | GuiScreen.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.BehaveChance import BehaveChance
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class ChozoGhost(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
hearing_radius: float = dataclasses.field(default=20.0)
fade_out_delay: float = dataclasses.field(default=2.5)
attack_delay: float = dataclasses.field(default=1.0)
freeze_time: float = dataclasses.field(default=2.0)
unknown_0x54151870: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage_info_0xffcda1f8: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x3a58089c: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
damage_info_0x1ff047a9: DamageInfo = dataclasses.field(default_factory=DamageInfo)
behave_chance_0xe832241f: BehaveChance = dataclasses.field(default_factory=BehaveChance)
behave_chance_0x1e2c8483: BehaveChance = dataclasses.field(default_factory=BehaveChance)
behave_chance_0x78d76034: BehaveChance = dataclasses.field(default_factory=BehaveChance)
sound_impact: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0xc87d7ec7: float = dataclasses.field(default=1.5)
right_disappear_crossfade: int = dataclasses.field(default=0, metadata={'sound': True})
sound: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0xec76940c: int = dataclasses.field(default=0)
unknown_0x723542bb: float = dataclasses.field(default=8.0)
unknown_0xfe9eac26: int = dataclasses.field(default=0)
hurl_recover_time: float = dataclasses.field(default=1.5)
projectile_visor_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sound_projectile_visor: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x61e511b3: float = dataclasses.field(default=20.0)
unknown_0x2369607a: float = dataclasses.field(default=45.0)
near_chance: int = dataclasses.field(default=40)
mid_chance: int = dataclasses.field(default=40)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'CHOG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ChozoGhost.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x1c') # 28 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'turn_speed': 720.0, 'detection_range': 25.0, 'min_attack_range': 8.0, 'max_attack_range': 70.0, 'leash_radius': 70.0, 'collision_height': 4.5, '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'\xediH\x8f') # 0xed69488f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hearing_radius))
data.write(b'\xfb\x12\xf6r') # 0xfb12f672
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_delay))
data.write(b'\x1bg\x98\x1a') # 0x1b67981a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_delay))
data.write(b'\x1e\x87"\xc7') # 0x1e8722c7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.freeze_time))
data.write(b'T\x15\x18p') # 0x54151870
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x54151870))
data.write(b'\xff\xcd\xa1\xf8') # 0xffcda1f8
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0xffcda1f8.to_stream(data, default_override={'di_damage': 10.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b':X\x08\x9c') # 0x3a58089c
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.unknown_0x3a58089c))
data.write(b'\x1f\xf0G\xa9') # 0x1ff047a9
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.damage_info_0x1ff047a9.to_stream(data, default_override={'di_damage': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xe82$\x1f') # 0xe832241f
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behave_chance_0xe832241f.to_stream(data, default_override={'lurk': 20.0, 'attack': 60.0, 'move': 20.0, 'lurk_time': 2.0, 'num_bolts': 1})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1e,\x84\x83') # 0x1e2c8483
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behave_chance_0x1e2c8483.to_stream(data, default_override={'lurk': 20.0, 'attack': 60.0, 'move': 10.0, 'lurk_time': 2.0, 'charge_attack': 20.0, 'num_bolts': 3})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'x\xd7`4') # 0x78d76034
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.behave_chance_0x78d76034.to_stream(data, default_override={'attack': 100.0, 'lurk_time': 2.0, 'charge_attack': 50.0, 'num_bolts': 2})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x1b\xb1n\xa5') # 0x1bb16ea5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_impact))
data.write(b'\xc8}~\xc7') # 0xc87d7ec7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xc87d7ec7))
data.write(b'*\xdc\xbb.') # 0x2adcbb2e
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.right_disappear_crossfade))
data.write(b'X\xb8\xec]') # 0x58b8ec5d
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound))
data.write(b'\xecv\x94\x0c') # 0xec76940c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xec76940c))
data.write(b'r5B\xbb') # 0x723542bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x723542bb))
data.write(b'\xfe\x9e\xac&') # 0xfe9eac26
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xfe9eac26))
data.write(b'\x96\xfe\xb7]') # 0x96feb75d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.hurl_recover_time))
data.write(b'\x8f\x8cd\xa0') # 0x8f8c64a0
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.projectile_visor_effect))
data.write(b'\xe1[OJ') # 0xe15b4f4a
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound_projectile_visor))
data.write(b'a\xe5\x11\xb3') # 0x61e511b3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61e511b3))
data.write(b'#i`z') # 0x2369607a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2369607a))
data.write(b'\xa6\xa3\x87\x9b') # 0xa6a3879b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.near_chance))
data.write(b"\x1b''\x81") # 0x1b272781
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.mid_chance))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
hearing_radius=data['hearing_radius'],
fade_out_delay=data['fade_out_delay'],
attack_delay=data['attack_delay'],
freeze_time=data['freeze_time'],
unknown_0x54151870=data['unknown_0x54151870'],
damage_info_0xffcda1f8=DamageInfo.from_json(data['damage_info_0xffcda1f8']),
unknown_0x3a58089c=data['unknown_0x3a58089c'],
damage_info_0x1ff047a9=DamageInfo.from_json(data['damage_info_0x1ff047a9']),
behave_chance_0xe832241f=BehaveChance.from_json(data['behave_chance_0xe832241f']),
behave_chance_0x1e2c8483=BehaveChance.from_json(data['behave_chance_0x1e2c8483']),
behave_chance_0x78d76034=BehaveChance.from_json(data['behave_chance_0x78d76034']),
sound_impact=data['sound_impact'],
unknown_0xc87d7ec7=data['unknown_0xc87d7ec7'],
right_disappear_crossfade=data['right_disappear_crossfade'],
sound=data['sound'],
unknown_0xec76940c=data['unknown_0xec76940c'],
unknown_0x723542bb=data['unknown_0x723542bb'],
unknown_0xfe9eac26=data['unknown_0xfe9eac26'],
hurl_recover_time=data['hurl_recover_time'],
projectile_visor_effect=data['projectile_visor_effect'],
sound_projectile_visor=data['sound_projectile_visor'],
unknown_0x61e511b3=data['unknown_0x61e511b3'],
unknown_0x2369607a=data['unknown_0x2369607a'],
near_chance=data['near_chance'],
mid_chance=data['mid_chance'],
)
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(),
'hearing_radius': self.hearing_radius,
'fade_out_delay': self.fade_out_delay,
'attack_delay': self.attack_delay,
'freeze_time': self.freeze_time,
'unknown_0x54151870': self.unknown_0x54151870,
'damage_info_0xffcda1f8': self.damage_info_0xffcda1f8.to_json(),
'unknown_0x3a58089c': self.unknown_0x3a58089c,
'damage_info_0x1ff047a9': self.damage_info_0x1ff047a9.to_json(),
'behave_chance_0xe832241f': self.behave_chance_0xe832241f.to_json(),
'behave_chance_0x1e2c8483': self.behave_chance_0x1e2c8483.to_json(),
'behave_chance_0x78d76034': self.behave_chance_0x78d76034.to_json(),
'sound_impact': self.sound_impact,
'unknown_0xc87d7ec7': self.unknown_0xc87d7ec7,
'right_disappear_crossfade': self.right_disappear_crossfade,
'sound': self.sound,
'unknown_0xec76940c': self.unknown_0xec76940c,
'unknown_0x723542bb': self.unknown_0x723542bb,
'unknown_0xfe9eac26': self.unknown_0xfe9eac26,
'hurl_recover_time': self.hurl_recover_time,
'projectile_visor_effect': self.projectile_visor_effect,
'sound_projectile_visor': self.sound_projectile_visor,
'unknown_0x61e511b3': self.unknown_0x61e511b3,
'unknown_0x2369607a': self.unknown_0x2369607a,
'near_chance': self.near_chance,
'mid_chance': self.mid_chance,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x54151870(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x54151870)
def _dependencies_for_damage_info_0xffcda1f8(self, asset_manager):
yield from self.damage_info_0xffcda1f8.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x3a58089c(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.unknown_0x3a58089c)
def _dependencies_for_damage_info_0x1ff047a9(self, asset_manager):
yield from self.damage_info_0x1ff047a9.dependencies_for(asset_manager)
def _dependencies_for_behave_chance_0xe832241f(self, asset_manager):
yield from self.behave_chance_0xe832241f.dependencies_for(asset_manager)
def _dependencies_for_behave_chance_0x1e2c8483(self, asset_manager):
yield from self.behave_chance_0x1e2c8483.dependencies_for(asset_manager)
def _dependencies_for_behave_chance_0x78d76034(self, asset_manager):
yield from self.behave_chance_0x78d76034.dependencies_for(asset_manager)
def _dependencies_for_sound_impact(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_impact)
def _dependencies_for_right_disappear_crossfade(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.right_disappear_crossfade)
def _dependencies_for_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound)
def _dependencies_for_projectile_visor_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.projectile_visor_effect)
def _dependencies_for_sound_projectile_visor(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound_projectile_visor)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_unknown_0x54151870, "unknown_0x54151870", "AssetId"),
(self._dependencies_for_damage_info_0xffcda1f8, "damage_info_0xffcda1f8", "DamageInfo"),
(self._dependencies_for_unknown_0x3a58089c, "unknown_0x3a58089c", "AssetId"),
(self._dependencies_for_damage_info_0x1ff047a9, "damage_info_0x1ff047a9", "DamageInfo"),
(self._dependencies_for_behave_chance_0xe832241f, "behave_chance_0xe832241f", "BehaveChance"),
(self._dependencies_for_behave_chance_0x1e2c8483, "behave_chance_0x1e2c8483", "BehaveChance"),
(self._dependencies_for_behave_chance_0x78d76034, "behave_chance_0x78d76034", "BehaveChance"),
(self._dependencies_for_sound_impact, "sound_impact", "int"),
(self._dependencies_for_right_disappear_crossfade, "right_disappear_crossfade", "int"),
(self._dependencies_for_sound, "sound", "int"),
(self._dependencies_for_projectile_visor_effect, "projectile_visor_effect", "AssetId"),
(self._dependencies_for_sound_projectile_visor, "sound_projectile_visor", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ChozoGhost.{field_name} ({field_type}): {e}"
)
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': 720.0, 'detection_range': 25.0, 'min_attack_range': 8.0, 'max_attack_range': 70.0, 'leash_radius': 70.0, 'collision_height': 4.5, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_hearing_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_delay(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_freeze_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x54151870(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_damage_info_0xffcda1f8(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_damage': 10.0})
def _decode_unknown_0x3a58089c(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_damage_info_0x1ff047a9(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_damage': 5.0})
def _decode_behave_chance_0xe832241f(data: typing.BinaryIO, property_size: int):
return BehaveChance.from_stream(data, property_size, default_override={'lurk': 20.0, 'attack': 60.0, 'move': 20.0, 'lurk_time': 2.0, 'num_bolts': 1})
def _decode_behave_chance_0x1e2c8483(data: typing.BinaryIO, property_size: int):
return BehaveChance.from_stream(data, property_size, default_override={'lurk': 20.0, 'attack': 60.0, 'move': 10.0, 'lurk_time': 2.0, 'charge_attack': 20.0, 'num_bolts': 3})
def _decode_behave_chance_0x78d76034(data: typing.BinaryIO, property_size: int):
return BehaveChance.from_stream(data, property_size, default_override={'attack': 100.0, 'lurk_time': 2.0, 'charge_attack': 50.0, 'num_bolts': 2})
def _decode_sound_impact(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc87d7ec7(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_right_disappear_crossfade(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xec76940c(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x723542bb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0xfe9eac26(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_hurl_recover_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_visor_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sound_projectile_visor(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x61e511b3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2369607a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_near_chance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_mid_chance(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0xed69488f: ('hearing_radius', _decode_hearing_radius),
0xfb12f672: ('fade_out_delay', _decode_fade_out_delay),
0x1b67981a: ('attack_delay', _decode_attack_delay),
0x1e8722c7: ('freeze_time', _decode_freeze_time),
0x54151870: ('unknown_0x54151870', _decode_unknown_0x54151870),
0xffcda1f8: ('damage_info_0xffcda1f8', _decode_damage_info_0xffcda1f8),
0x3a58089c: ('unknown_0x3a58089c', _decode_unknown_0x3a58089c),
0x1ff047a9: ('damage_info_0x1ff047a9', _decode_damage_info_0x1ff047a9),
0xe832241f: ('behave_chance_0xe832241f', _decode_behave_chance_0xe832241f),
0x1e2c8483: ('behave_chance_0x1e2c8483', _decode_behave_chance_0x1e2c8483),
0x78d76034: ('behave_chance_0x78d76034', _decode_behave_chance_0x78d76034),
0x1bb16ea5: ('sound_impact', _decode_sound_impact),
0xc87d7ec7: ('unknown_0xc87d7ec7', _decode_unknown_0xc87d7ec7),
0x2adcbb2e: ('right_disappear_crossfade', _decode_right_disappear_crossfade),
0x58b8ec5d: ('sound', _decode_sound),
0xec76940c: ('unknown_0xec76940c', _decode_unknown_0xec76940c),
0x723542bb: ('unknown_0x723542bb', _decode_unknown_0x723542bb),
0xfe9eac26: ('unknown_0xfe9eac26', _decode_unknown_0xfe9eac26),
0x96feb75d: ('hurl_recover_time', _decode_hurl_recover_time),
0x8f8c64a0: ('projectile_visor_effect', _decode_projectile_visor_effect),
0xe15b4f4a: ('sound_projectile_visor', _decode_sound_projectile_visor),
0x61e511b3: ('unknown_0x61e511b3', _decode_unknown_0x61e511b3),
0x2369607a: ('unknown_0x2369607a', _decode_unknown_0x2369607a),
0xa6a3879b: ('near_chance', _decode_near_chance),
0x1b272781: ('mid_chance', _decode_mid_chance),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ChozoGhost.py | 0.590779 | 0.235196 | ChozoGhost.py | 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.echoes as enums
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class SpecialFunction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
function: enums.Function = dataclasses.field(default=enums.Function.What)
string_parm: str = dataclasses.field(default='')
value_parm: float = dataclasses.field(default=0.0)
value_parm2: float = dataclasses.field(default=0.0)
value_parm3: float = dataclasses.field(default=0.0)
value_parm4: float = dataclasses.field(default=0.0)
int_parm1: int = dataclasses.field(default=0)
int_parm2: int = dataclasses.field(default=0)
inventory_item_parm: enums.PlayerItem = dataclasses.field(default=enums.PlayerItem.PowerBeam)
sound1: int = dataclasses.field(default=0, metadata={'sound': True})
sound2: int = dataclasses.field(default=0, metadata={'sound': True})
sound3: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SPFN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x95\xf8\xd6D') # 0x95f8d644
data.write(b'\x00\x04') # size
self.function.to_stream(data)
data.write(b'\x9dzWm') # 0x9d7a576d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.string_parm.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x19\x02\x80\x99') # 0x19028099
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm))
data.write(b',\x93\xaa\xf5') # 0x2c93aaf5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm2))
data.write(b'\xe7\xcfyP') # 0xe7cf7950
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm3))
data.write(b'\xfa\xcaI\xe8') # 0xfaca49e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.value_parm4))
data.write(b'\xa74\xf8\xa5') # 0xa734f8a5
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.int_parm1))
data.write(b'\xb5\x81WK') # 0xb581574b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.int_parm2))
data.write(b'?\xa1d\xbc') # 0x3fa164bc
data.write(b'\x00\x04') # size
self.inventory_item_parm.to_stream(data)
data.write(b'\xa4\xee\x16\xbf') # 0xa4ee16bf
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound1))
data.write(b'"zd\x11') # 0x227a6411
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound2))
data.write(b'\xe9&\xb7\xb4') # 0xe926b7b4
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.sound3))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
function=enums.Function.from_json(data['function']),
string_parm=data['string_parm'],
value_parm=data['value_parm'],
value_parm2=data['value_parm2'],
value_parm3=data['value_parm3'],
value_parm4=data['value_parm4'],
int_parm1=data['int_parm1'],
int_parm2=data['int_parm2'],
inventory_item_parm=enums.PlayerItem.from_json(data['inventory_item_parm']),
sound1=data['sound1'],
sound2=data['sound2'],
sound3=data['sound3'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'function': self.function.to_json(),
'string_parm': self.string_parm,
'value_parm': self.value_parm,
'value_parm2': self.value_parm2,
'value_parm3': self.value_parm3,
'value_parm4': self.value_parm4,
'int_parm1': self.int_parm1,
'int_parm2': self.int_parm2,
'inventory_item_parm': self.inventory_item_parm.to_json(),
'sound1': self.sound1,
'sound2': self.sound2,
'sound3': self.sound3,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_sound1(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound1)
def _dependencies_for_sound2(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound2)
def _dependencies_for_sound3(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.sound3)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_sound1, "sound1", "int"),
(self._dependencies_for_sound2, "sound2", "int"),
(self._dependencies_for_sound3, "sound3", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SpecialFunction.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_function(data: typing.BinaryIO, property_size: int):
return enums.Function.from_stream(data)
def _decode_string_parm(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_value_parm(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm3(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_value_parm4(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_int_parm1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_int_parm2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_inventory_item_parm(data: typing.BinaryIO, property_size: int):
return enums.PlayerItem.from_stream(data)
def _decode_sound1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_sound3(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),
0x95f8d644: ('function', _decode_function),
0x9d7a576d: ('string_parm', _decode_string_parm),
0x19028099: ('value_parm', _decode_value_parm),
0x2c93aaf5: ('value_parm2', _decode_value_parm2),
0xe7cf7950: ('value_parm3', _decode_value_parm3),
0xfaca49e8: ('value_parm4', _decode_value_parm4),
0xa734f8a5: ('int_parm1', _decode_int_parm1),
0xb581574b: ('int_parm2', _decode_int_parm2),
0x3fa164bc: ('inventory_item_parm', _decode_inventory_item_parm),
0xa4ee16bf: ('sound1', _decode_sound1),
0x227a6411: ('sound2', _decode_sound2),
0xe926b7b4: ('sound3', _decode_sound3),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SpecialFunction.py | 0.518546 | 0.30905 | SpecialFunction.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DynamicLightFalloff import DynamicLightFalloff
from retro_data_structures.properties.echoes.archetypes.DynamicLightIntensity import DynamicLightIntensity
from retro_data_structures.properties.echoes.archetypes.DynamicLightMotionSpline import DynamicLightMotionSpline
from retro_data_structures.properties.echoes.archetypes.DynamicLightParent import DynamicLightParent
from retro_data_structures.properties.echoes.archetypes.DynamicLightSpotlight import DynamicLightSpotlight
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class DynamicLight(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
light_type: int = dataclasses.field(default=2)
light_set: int = dataclasses.field(default=6)
color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
intensity: DynamicLightIntensity = dataclasses.field(default_factory=DynamicLightIntensity)
falloff: DynamicLightFalloff = dataclasses.field(default_factory=DynamicLightFalloff)
spotlight: DynamicLightSpotlight = dataclasses.field(default_factory=DynamicLightSpotlight)
motion_spline: DynamicLightMotionSpline = dataclasses.field(default_factory=DynamicLightMotionSpline)
parent: DynamicLightParent = dataclasses.field(default_factory=DynamicLightParent)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DLHT'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\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'\x7f\xc4\xe36') # 0x7fc4e336
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.light_type))
data.write(b'>\x8b;/') # 0x3e8b3b2f
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.light_set))
data.write(b'7\xc7\xd0\x9d') # 0x37c7d09d
data.write(b'\x00\x10') # size
self.color.to_stream(data)
data.write(b'rS\x1e\xde') # 0x72531ede
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.intensity.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'!\x9bR\xda') # 0x219b52da
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.falloff.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x95F\xf4I') # 0x9546f449
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spotlight.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x142!8') # 0x14322138
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.motion_spline.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf74\xdf\x8c') # 0xf734df8c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.parent.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
light_type=data['light_type'],
light_set=data['light_set'],
color=Color.from_json(data['color']),
intensity=DynamicLightIntensity.from_json(data['intensity']),
falloff=DynamicLightFalloff.from_json(data['falloff']),
spotlight=DynamicLightSpotlight.from_json(data['spotlight']),
motion_spline=DynamicLightMotionSpline.from_json(data['motion_spline']),
parent=DynamicLightParent.from_json(data['parent']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'light_type': self.light_type,
'light_set': self.light_set,
'color': self.color.to_json(),
'intensity': self.intensity.to_json(),
'falloff': self.falloff.to_json(),
'spotlight': self.spotlight.to_json(),
'motion_spline': self.motion_spline.to_json(),
'parent': self.parent.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_intensity(self, asset_manager):
yield from self.intensity.dependencies_for(asset_manager)
def _dependencies_for_falloff(self, asset_manager):
yield from self.falloff.dependencies_for(asset_manager)
def _dependencies_for_spotlight(self, asset_manager):
yield from self.spotlight.dependencies_for(asset_manager)
def _dependencies_for_motion_spline(self, asset_manager):
yield from self.motion_spline.dependencies_for(asset_manager)
def _dependencies_for_parent(self, asset_manager):
yield from self.parent.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_intensity, "intensity", "DynamicLightIntensity"),
(self._dependencies_for_falloff, "falloff", "DynamicLightFalloff"),
(self._dependencies_for_spotlight, "spotlight", "DynamicLightSpotlight"),
(self._dependencies_for_motion_spline, "motion_spline", "DynamicLightMotionSpline"),
(self._dependencies_for_parent, "parent", "DynamicLightParent"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DynamicLight.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_light_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_light_set(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_intensity(data: typing.BinaryIO, property_size: int):
return DynamicLightIntensity.from_stream(data, property_size)
def _decode_falloff(data: typing.BinaryIO, property_size: int):
return DynamicLightFalloff.from_stream(data, property_size)
def _decode_spotlight(data: typing.BinaryIO, property_size: int):
return DynamicLightSpotlight.from_stream(data, property_size)
def _decode_motion_spline(data: typing.BinaryIO, property_size: int):
return DynamicLightMotionSpline.from_stream(data, property_size)
def _decode_parent(data: typing.BinaryIO, property_size: int):
return DynamicLightParent.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7fc4e336: ('light_type', _decode_light_type),
0x3e8b3b2f: ('light_set', _decode_light_set),
0x37c7d09d: ('color', _decode_color),
0x72531ede: ('intensity', _decode_intensity),
0x219b52da: ('falloff', _decode_falloff),
0x9546f449: ('spotlight', _decode_spotlight),
0x14322138: ('motion_spline', _decode_motion_spline),
0xf734df8c: ('parent', _decode_parent),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DynamicLight.py | 0.610918 | 0.345354 | DynamicLight.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.MysteryFlyerData import MysteryFlyerData
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
@dataclasses.dataclass()
class MysteryFlyer(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
mystery_flyer_properties: MysteryFlyerData = dataclasses.field(default_factory=MysteryFlyerData)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'MYSF'
@classmethod
def modules(cls) -> typing.List[str]:
return ['MysteryFlyer.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x04') # 4 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'D\x08\x05e') # 0x44080565
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.mystery_flyer_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
mystery_flyer_properties=MysteryFlyerData.from_json(data['mystery_flyer_properties']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'patterned': self.patterned.to_json(),
'actor_information': self.actor_information.to_json(),
'mystery_flyer_properties': self.mystery_flyer_properties.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_mystery_flyer_properties(self, asset_manager):
yield from self.mystery_flyer_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_mystery_flyer_properties, "mystery_flyer_properties", "MysteryFlyerData"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for MysteryFlyer.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_patterned(data: typing.BinaryIO, property_size: int):
return PatternedAITypedef.from_stream(data, property_size)
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_mystery_flyer_properties(data: typing.BinaryIO, property_size: int):
return MysteryFlyerData.from_stream(data, property_size)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x44080565: ('mystery_flyer_properties', _decode_mystery_flyer_properties),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/MysteryFlyer.py | 0.627951 | 0.324824 | MysteryFlyer.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
@dataclasses.dataclass()
class FishCloud(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
active: bool = dataclasses.field(default=True)
fish_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
fish_count: float = dataclasses.field(default=20.0)
speed: float = dataclasses.field(default=3.0)
influence_distance: float = dataclasses.field(default=2.0)
unknown_0x61959f0d: float = dataclasses.field(default=0.4000000059604645)
alignment_priority: float = dataclasses.field(default=0.8999999761581421)
separation_priority: float = dataclasses.field(default=1.0)
projectile_priority: float = dataclasses.field(default=1.0)
player_priority: float = dataclasses.field(default=0.4000000059604645)
containment_priority: float = dataclasses.field(default=0.20000000298023224)
wander_priority: float = dataclasses.field(default=0.0)
wander_amount: float = dataclasses.field(default=0.0)
player_ball_priority: float = dataclasses.field(default=0.0)
player_ball_distance: float = dataclasses.field(default=30.0)
projectile_decay_rate: float = dataclasses.field(default=0.10000000149011612)
player_decay_rate: float = dataclasses.field(default=0.10000000149011612)
look_ahead_time: float = dataclasses.field(default=0.5)
update_frame: int = dataclasses.field(default=3)
material_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
can_be_killed: bool = dataclasses.field(default=False)
collision_radius: float = dataclasses.field(default=0.0)
death_effect0: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death_effect0_count: int = dataclasses.field(default=0)
death_effect1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death_effect1_count: int = dataclasses.field(default=0)
death_effect2: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
death_effect2_count: int = dataclasses.field(default=0)
death_effect3: AssetId = dataclasses.field(metadata={'asset_types': []}, default=default_asset_id)
death_effect3_count: int = dataclasses.field(default=0)
death_sound: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0xc320a050: bool = dataclasses.field(default=True)
unknown_0xcd4c81a1: bool = dataclasses.field(default=True)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'FISH'
@classmethod
def modules(cls) -> typing.List[str]:
return ['FishCloud.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00#') # 35 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_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\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'y\x90\xa3\xb6') # 0x7990a3b6
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.fish_model))
data.write(b'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf1\xc0ru') # 0xf1c07275
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fish_count))
data.write(b'c\x92@N') # 0x6392404e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.speed))
data.write(b'xd\xad\x0e') # 0x7864ad0e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.influence_distance))
data.write(b'a\x95\x9f\r') # 0x61959f0d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x61959f0d))
data.write(b'HA\xf1\xde') # 0x4841f1de
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.alignment_priority))
data.write(b'\xd2\x93\xeb\xc4') # 0xd293ebc4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.separation_priority))
data.write(b'_6*\x14') # 0x5f362a14
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_priority))
data.write(b'\xec\x9bs\xc2') # 0xec9b73c2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_priority))
data.write(b'\x7f\xf1F\x9e') # 0x7ff1469e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.containment_priority))
data.write(b'|\xe1xp') # 0x7ce17870
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wander_priority))
data.write(b':%\xf0\x9d') # 0x3a25f09d
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.wander_amount))
data.write(b'#\xa1`\xf3') # 0x23a160f3
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_ball_priority))
data.write(b'\xf0g\x14\x10') # 0xf0671410
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_ball_distance))
data.write(b'\xa1trh') # 0xa1747268
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.projectile_decay_rate))
data.write(b'\xcew\xa8\xd0') # 0xce77a8d0
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.player_decay_rate))
data.write(b'\x8c\xb2\x0cS') # 0x8cb20c53
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.look_ahead_time))
data.write(b'!\xb3\xd0|') # 0x21b3d07c
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.update_frame))
data.write(b'\x1f\x83\xd3P') # 0x1f83d350
data.write(b'\x00\x10') # size
self.material_color.to_stream(data)
data.write(b'\xf60\xb8\x9f') # 0xf630b89f
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.can_be_killed))
data.write(b'\x8aj\xb19') # 0x8a6ab139
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.collision_radius))
data.write(b'[\xa8bE') # 0x5ba86245
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_effect0))
data.write(b'\xa8#/\xb1') # 0xa8232fb1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect0_count))
data.write(b'\x90\xf4\xb1\xe0') # 0x90f4b1e0
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_effect1))
data.write(b'\xbfX;\xf2') # 0xbf583bf2
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect1_count))
data.write(b'\x16`\xc3N') # 0x1660c34e
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_effect2))
data.write(b'\x86\xd5\x077') # 0x86d50737
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect2_count))
data.write(b'\xdd<\x10\xeb') # 0xdd3c10eb
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_effect3))
data.write(b'\x91\xae\x13t') # 0x91ae1374
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_effect3_count))
data.write(b'=\xe2o\xc8') # 0x3de26fc8
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.death_sound))
data.write(b'\xc3 \xa0P') # 0xc320a050
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xc320a050))
data.write(b'\xcdL\x81\xa1') # 0xcd4c81a1
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xcd4c81a1))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
active=data['active'],
fish_model=data['fish_model'],
animation_information=AnimationParameters.from_json(data['animation_information']),
fish_count=data['fish_count'],
speed=data['speed'],
influence_distance=data['influence_distance'],
unknown_0x61959f0d=data['unknown_0x61959f0d'],
alignment_priority=data['alignment_priority'],
separation_priority=data['separation_priority'],
projectile_priority=data['projectile_priority'],
player_priority=data['player_priority'],
containment_priority=data['containment_priority'],
wander_priority=data['wander_priority'],
wander_amount=data['wander_amount'],
player_ball_priority=data['player_ball_priority'],
player_ball_distance=data['player_ball_distance'],
projectile_decay_rate=data['projectile_decay_rate'],
player_decay_rate=data['player_decay_rate'],
look_ahead_time=data['look_ahead_time'],
update_frame=data['update_frame'],
material_color=Color.from_json(data['material_color']),
can_be_killed=data['can_be_killed'],
collision_radius=data['collision_radius'],
death_effect0=data['death_effect0'],
death_effect0_count=data['death_effect0_count'],
death_effect1=data['death_effect1'],
death_effect1_count=data['death_effect1_count'],
death_effect2=data['death_effect2'],
death_effect2_count=data['death_effect2_count'],
death_effect3=data['death_effect3'],
death_effect3_count=data['death_effect3_count'],
death_sound=data['death_sound'],
unknown_0xc320a050=data['unknown_0xc320a050'],
unknown_0xcd4c81a1=data['unknown_0xcd4c81a1'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'active': self.active,
'fish_model': self.fish_model,
'animation_information': self.animation_information.to_json(),
'fish_count': self.fish_count,
'speed': self.speed,
'influence_distance': self.influence_distance,
'unknown_0x61959f0d': self.unknown_0x61959f0d,
'alignment_priority': self.alignment_priority,
'separation_priority': self.separation_priority,
'projectile_priority': self.projectile_priority,
'player_priority': self.player_priority,
'containment_priority': self.containment_priority,
'wander_priority': self.wander_priority,
'wander_amount': self.wander_amount,
'player_ball_priority': self.player_ball_priority,
'player_ball_distance': self.player_ball_distance,
'projectile_decay_rate': self.projectile_decay_rate,
'player_decay_rate': self.player_decay_rate,
'look_ahead_time': self.look_ahead_time,
'update_frame': self.update_frame,
'material_color': self.material_color.to_json(),
'can_be_killed': self.can_be_killed,
'collision_radius': self.collision_radius,
'death_effect0': self.death_effect0,
'death_effect0_count': self.death_effect0_count,
'death_effect1': self.death_effect1,
'death_effect1_count': self.death_effect1_count,
'death_effect2': self.death_effect2,
'death_effect2_count': self.death_effect2_count,
'death_effect3': self.death_effect3,
'death_effect3_count': self.death_effect3_count,
'death_sound': self.death_sound,
'unknown_0xc320a050': self.unknown_0xc320a050,
'unknown_0xcd4c81a1': self.unknown_0xcd4c81a1,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_fish_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.fish_model)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_death_effect0(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_effect0)
def _dependencies_for_death_effect1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_effect1)
def _dependencies_for_death_effect2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_effect2)
def _dependencies_for_death_effect3(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_effect3)
def _dependencies_for_death_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.death_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_fish_model, "fish_model", "AssetId"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_death_effect0, "death_effect0", "AssetId"),
(self._dependencies_for_death_effect1, "death_effect1", "AssetId"),
(self._dependencies_for_death_effect2, "death_effect2", "AssetId"),
(self._dependencies_for_death_effect3, "death_effect3", "AssetId"),
(self._dependencies_for_death_sound, "death_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for FishCloud.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_active(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_fish_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_animation_information(data: typing.BinaryIO, property_size: int):
return AnimationParameters.from_stream(data, property_size)
def _decode_fish_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_influence_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x61959f0d(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_alignment_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_separation_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_containment_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wander_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_wander_amount(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_ball_priority(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_ball_distance(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_projectile_decay_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_player_decay_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_look_ahead_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_update_frame(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_material_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_can_be_killed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_collision_radius(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_death_effect0(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_effect0_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_effect1_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_effect2_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_effect3(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_effect3_count(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_death_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xc320a050(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xcd4c81a1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xc6bb2f45: ('active', _decode_active),
0x7990a3b6: ('fish_model', _decode_fish_model),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xf1c07275: ('fish_count', _decode_fish_count),
0x6392404e: ('speed', _decode_speed),
0x7864ad0e: ('influence_distance', _decode_influence_distance),
0x61959f0d: ('unknown_0x61959f0d', _decode_unknown_0x61959f0d),
0x4841f1de: ('alignment_priority', _decode_alignment_priority),
0xd293ebc4: ('separation_priority', _decode_separation_priority),
0x5f362a14: ('projectile_priority', _decode_projectile_priority),
0xec9b73c2: ('player_priority', _decode_player_priority),
0x7ff1469e: ('containment_priority', _decode_containment_priority),
0x7ce17870: ('wander_priority', _decode_wander_priority),
0x3a25f09d: ('wander_amount', _decode_wander_amount),
0x23a160f3: ('player_ball_priority', _decode_player_ball_priority),
0xf0671410: ('player_ball_distance', _decode_player_ball_distance),
0xa1747268: ('projectile_decay_rate', _decode_projectile_decay_rate),
0xce77a8d0: ('player_decay_rate', _decode_player_decay_rate),
0x8cb20c53: ('look_ahead_time', _decode_look_ahead_time),
0x21b3d07c: ('update_frame', _decode_update_frame),
0x1f83d350: ('material_color', _decode_material_color),
0xf630b89f: ('can_be_killed', _decode_can_be_killed),
0x8a6ab139: ('collision_radius', _decode_collision_radius),
0x5ba86245: ('death_effect0', _decode_death_effect0),
0xa8232fb1: ('death_effect0_count', _decode_death_effect0_count),
0x90f4b1e0: ('death_effect1', _decode_death_effect1),
0xbf583bf2: ('death_effect1_count', _decode_death_effect1_count),
0x1660c34e: ('death_effect2', _decode_death_effect2),
0x86d50737: ('death_effect2_count', _decode_death_effect2_count),
0xdd3c10eb: ('death_effect3', _decode_death_effect3),
0x91ae1374: ('death_effect3_count', _decode_death_effect3_count),
0x3de26fc8: ('death_sound', _decode_death_sound),
0xc320a050: ('unknown_0xc320a050', _decode_unknown_0xc320a050),
0xcd4c81a1: ('unknown_0xcd4c81a1', _decode_unknown_0xcd4c81a1),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/FishCloud.py | 0.632389 | 0.225705 | FishCloud.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.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.ECHOES
def get_name(self) -> typing.Optional[str]:
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 _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_damage(self, asset_manager):
yield from self.damage.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_damage, "damage", "DamageInfo"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DamageActor.{field_name} ({field_type}): {e}"
)
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/echoes/objects/DamageActor.py | 0.605566 | 0.33595 | 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.echoes.archetypes.ControllerActionStruct import ControllerActionStruct
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class ControllerAction(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
controller_action_struct: ControllerActionStruct = dataclasses.field(default_factory=ControllerActionStruct)
one_shot: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
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\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'Ln\xef\xae') # 0x4c6eefae
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.controller_action_struct.to_stream(data, default_override={'command': 1})
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']),
controller_action_struct=ControllerActionStruct.from_json(data['controller_action_struct']),
one_shot=data['one_shot'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'controller_action_struct': self.controller_action_struct.to_json(),
'one_shot': self.one_shot,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_controller_action_struct(self, asset_manager):
yield from self.controller_action_struct.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_controller_action_struct, "controller_action_struct", "ControllerActionStruct"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for ControllerAction.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_controller_action_struct(data: typing.BinaryIO, property_size: int):
return ControllerActionStruct.from_stream(data, property_size, default_override={'command': 1})
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),
0x4c6eefae: ('controller_action_struct', _decode_controller_action_struct),
0xead7b7bb: ('one_shot', _decode_one_shot),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/ControllerAction.py | 0.611382 | 0.325896 | 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.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.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: int = dataclasses.field(default=0)
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.ECHOES
def get_name(self) -> typing.Optional[str]:
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\x04') # size
data.write(struct.pack(">L", self.particle))
data.write(b'q\xdb\xe2\xf2') # 0x71dbe2f2
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", 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'\xa6\xdc\x9a\x92') # 0xa6dc9a92
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', 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 _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle)
def _dependencies_for_electric(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.electric)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_particle, "particle", "AssetId"),
(self._dependencies_for_electric, "electric", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for VisorGoo.{field_name} ({field_type}): {e}"
)
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(">L", data.read(4))[0]
def _decode_electric(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[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('>l', data.read(4))[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),
0xa6dc9a92: ('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/echoes/objects/VisorGoo.py | 0.578091 | 0.302964 | 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.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class PlayerTurret(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
flags_player_turret: int = dataclasses.field(default=1)
unknown_0x17cd8b2a: float = dataclasses.field(default=90.0)
unknown_0x1473dad2: float = dataclasses.field(default=90.0)
unknown_0x3650ce75: float = dataclasses.field(default=90.0)
unknown_0x78520e6e: float = dataclasses.field(default=0.0)
damage_angle: float = dataclasses.field(default=30.0)
horiz_speed: float = dataclasses.field(default=30.0)
vert_speed: float = dataclasses.field(default=30.0)
fire_rate: float = dataclasses.field(default=1.0)
weapon_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
weapon_effect: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
wpsc: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
unknown_0xe7234f72: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x3e2f7afb: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x7cabd1f1: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x7ef976eb: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x035459fd: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PLRT'
@classmethod
def modules(cls) -> typing.List[str]:
return ['ScriptPlayerTurret.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xee\xad\xef\xa6') # 0xeeadefa6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.flags_player_turret))
data.write(b'\x17\xcd\x8b*') # 0x17cd8b2a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x17cd8b2a))
data.write(b'\x14s\xda\xd2') # 0x1473dad2
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x1473dad2))
data.write(b'6P\xceu') # 0x3650ce75
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x3650ce75))
data.write(b'xR\x0en') # 0x78520e6e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x78520e6e))
data.write(b'\xa3\x9a]r') # 0xa39a5d72
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.damage_angle))
data.write(b'\xfb.2\xdb') # 0xfb2e32db
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.horiz_speed))
data.write(b'\x1b<\x86\x83') # 0x1b3c8683
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.vert_speed))
data.write(b'\xc6\xe4\x8f\x18') # 0xc6e48f18
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fire_rate))
data.write(b'\x8e_~\x96') # 0x8e5f7e96
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.weapon_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc43`\xa7') # 0xc43360a7
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.weapon_effect))
data.write(b'\xa9\x9d=\xbe') # 0xa99d3dbe
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.wpsc))
data.write(b'\xe7#Or') # 0xe7234f72
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xe7234f72))
data.write(b'>/z\xfb') # 0x3e2f7afb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x3e2f7afb))
data.write(b'|\xab\xd1\xf1') # 0x7cabd1f1
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7cabd1f1))
data.write(b'~\xf9v\xeb') # 0x7ef976eb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7ef976eb))
data.write(b'\x03TY\xfd') # 0x35459fd
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x035459fd))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
flags_player_turret=data['flags_player_turret'],
unknown_0x17cd8b2a=data['unknown_0x17cd8b2a'],
unknown_0x1473dad2=data['unknown_0x1473dad2'],
unknown_0x3650ce75=data['unknown_0x3650ce75'],
unknown_0x78520e6e=data['unknown_0x78520e6e'],
damage_angle=data['damage_angle'],
horiz_speed=data['horiz_speed'],
vert_speed=data['vert_speed'],
fire_rate=data['fire_rate'],
weapon_damage=DamageInfo.from_json(data['weapon_damage']),
weapon_effect=data['weapon_effect'],
wpsc=data['wpsc'],
unknown_0xe7234f72=data['unknown_0xe7234f72'],
unknown_0x3e2f7afb=data['unknown_0x3e2f7afb'],
unknown_0x7cabd1f1=data['unknown_0x7cabd1f1'],
unknown_0x7ef976eb=data['unknown_0x7ef976eb'],
unknown_0x035459fd=data['unknown_0x035459fd'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'flags_player_turret': self.flags_player_turret,
'unknown_0x17cd8b2a': self.unknown_0x17cd8b2a,
'unknown_0x1473dad2': self.unknown_0x1473dad2,
'unknown_0x3650ce75': self.unknown_0x3650ce75,
'unknown_0x78520e6e': self.unknown_0x78520e6e,
'damage_angle': self.damage_angle,
'horiz_speed': self.horiz_speed,
'vert_speed': self.vert_speed,
'fire_rate': self.fire_rate,
'weapon_damage': self.weapon_damage.to_json(),
'weapon_effect': self.weapon_effect,
'wpsc': self.wpsc,
'unknown_0xe7234f72': self.unknown_0xe7234f72,
'unknown_0x3e2f7afb': self.unknown_0x3e2f7afb,
'unknown_0x7cabd1f1': self.unknown_0x7cabd1f1,
'unknown_0x7ef976eb': self.unknown_0x7ef976eb,
'unknown_0x035459fd': self.unknown_0x035459fd,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_weapon_damage(self, asset_manager):
yield from self.weapon_damage.dependencies_for(asset_manager)
def _dependencies_for_weapon_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.weapon_effect)
def _dependencies_for_wpsc(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.wpsc)
def _dependencies_for_unknown_0xe7234f72(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0xe7234f72)
def _dependencies_for_unknown_0x3e2f7afb(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x3e2f7afb)
def _dependencies_for_unknown_0x7cabd1f1(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x7cabd1f1)
def _dependencies_for_unknown_0x7ef976eb(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x7ef976eb)
def _dependencies_for_unknown_0x035459fd(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x035459fd)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_weapon_damage, "weapon_damage", "DamageInfo"),
(self._dependencies_for_weapon_effect, "weapon_effect", "AssetId"),
(self._dependencies_for_wpsc, "wpsc", "AssetId"),
(self._dependencies_for_unknown_0xe7234f72, "unknown_0xe7234f72", "int"),
(self._dependencies_for_unknown_0x3e2f7afb, "unknown_0x3e2f7afb", "int"),
(self._dependencies_for_unknown_0x7cabd1f1, "unknown_0x7cabd1f1", "int"),
(self._dependencies_for_unknown_0x7ef976eb, "unknown_0x7ef976eb", "int"),
(self._dependencies_for_unknown_0x035459fd, "unknown_0x035459fd", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PlayerTurret.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_flags_player_turret(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x17cd8b2a(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x1473dad2(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x3650ce75(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x78520e6e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_damage_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_horiz_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_vert_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fire_rate(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_weapon_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_weapon_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_wpsc(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xe7234f72(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x3e2f7afb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7cabd1f1(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x7ef976eb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x035459fd(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),
0xeeadefa6: ('flags_player_turret', _decode_flags_player_turret),
0x17cd8b2a: ('unknown_0x17cd8b2a', _decode_unknown_0x17cd8b2a),
0x1473dad2: ('unknown_0x1473dad2', _decode_unknown_0x1473dad2),
0x3650ce75: ('unknown_0x3650ce75', _decode_unknown_0x3650ce75),
0x78520e6e: ('unknown_0x78520e6e', _decode_unknown_0x78520e6e),
0xa39a5d72: ('damage_angle', _decode_damage_angle),
0xfb2e32db: ('horiz_speed', _decode_horiz_speed),
0x1b3c8683: ('vert_speed', _decode_vert_speed),
0xc6e48f18: ('fire_rate', _decode_fire_rate),
0x8e5f7e96: ('weapon_damage', _decode_weapon_damage),
0xc43360a7: ('weapon_effect', _decode_weapon_effect),
0xa99d3dbe: ('wpsc', _decode_wpsc),
0xe7234f72: ('unknown_0xe7234f72', _decode_unknown_0xe7234f72),
0x3e2f7afb: ('unknown_0x3e2f7afb', _decode_unknown_0x3e2f7afb),
0x7cabd1f1: ('unknown_0x7cabd1f1', _decode_unknown_0x7cabd1f1),
0x7ef976eb: ('unknown_0x7ef976eb', _decode_unknown_0x7ef976eb),
0x35459fd: ('unknown_0x035459fd', _decode_unknown_0x035459fd),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PlayerTurret.py | 0.563618 | 0.241534 | PlayerTurret.py | 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.echoes as enums
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class AreaAttributes(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
need_sky: bool = dataclasses.field(default=False)
dark_world: bool = dataclasses.field(default=False)
environment_effects: enums.EnvironmentEffects = dataclasses.field(default=enums.EnvironmentEffects._None)
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)
override_sky: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
phazon_damage: enums.PhazonDamage = dataclasses.field(default=enums.PhazonDamage._None)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
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\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'\x95\xd4\xbe\xe7') # 0x95d4bee7
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.need_sky))
data.write(b'\xb2O\xde\x1a') # 0xb24fde1a
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.dark_world))
data.write(b'\x9d\x00\x06\xab') # 0x9d0006ab
data.write(b'\x00\x04') # size
self.environment_effects.to_stream(data)
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'\xd2\x08\xc9\xfa') # 0xd208c9fa
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.override_sky))
data.write(b'\xff\xee\xbcF') # 0xffeebc46
data.write(b'\x00\x04') # size
self.phazon_damage.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']),
need_sky=data['need_sky'],
dark_world=data['dark_world'],
environment_effects=enums.EnvironmentEffects.from_json(data['environment_effects']),
environment_group_sound=data['environment_group_sound'],
density=data['density'],
normal_lighting=data['normal_lighting'],
override_sky=data['override_sky'],
phazon_damage=enums.PhazonDamage.from_json(data['phazon_damage']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'need_sky': self.need_sky,
'dark_world': self.dark_world,
'environment_effects': self.environment_effects.to_json(),
'environment_group_sound': self.environment_group_sound,
'density': self.density,
'normal_lighting': self.normal_lighting,
'override_sky': self.override_sky,
'phazon_damage': self.phazon_damage.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_environment_group_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.environment_group_sound)
def _dependencies_for_override_sky(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.override_sky)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_environment_group_sound, "environment_group_sound", "int"),
(self._dependencies_for_override_sky, "override_sky", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AreaAttributes.{field_name} ({field_type}): {e}"
)
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_dark_world(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_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_override_sky(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_phazon_damage(data: typing.BinaryIO, property_size: int):
return enums.PhazonDamage.from_stream(data)
_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),
0xb24fde1a: ('dark_world', _decode_dark_world),
0x9d0006ab: ('environment_effects', _decode_environment_effects),
0x56263e35: ('environment_group_sound', _decode_environment_group_sound),
0x64e5fe9f: ('density', _decode_density),
0xba5f801e: ('normal_lighting', _decode_normal_lighting),
0xd208c9fa: ('override_sky', _decode_override_sky),
0xffeebc46: ('phazon_damage', _decode_phazon_damage),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AreaAttributes.py | 0.59843 | 0.29814 | 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.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.BasicSwarmProperties import BasicSwarmProperties
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class IngBlobSwarm(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
animation_information: AnimationParameters = dataclasses.field(default_factory=AnimationParameters)
active: bool = dataclasses.field(default=True)
basic_swarm_properties: BasicSwarmProperties = dataclasses.field(default_factory=BasicSwarmProperties)
unknown_0x7399abbb: int = dataclasses.field(default=0, metadata={'sound': True})
unknown_0x734d923b: int = dataclasses.field(default=0)
max_attack_angle: float = dataclasses.field(default=30.0)
into_attack_speed: float = dataclasses.field(default=1.0)
attack_speed: float = dataclasses.field(default=1.0)
mass: float = dataclasses.field(default=2.0)
max_attack_height: float = dataclasses.field(default=0.5)
attack_aim_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'IBSM'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SwarmBasics.rel', 'IngBlobSwarm.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'~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'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xc6\xbb/E') # 0xc6bb2f45
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.active))
data.write(b'\xe1\xecsF') # 0xe1ec7346
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.basic_swarm_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b's\x99\xab\xbb') # 0x7399abbb
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x7399abbb))
data.write(b'sM\x92;') # 0x734d923b
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0x734d923b))
data.write(b'\xf1\x1fs\x84') # 0xf11f7384
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_angle))
data.write(b'\xcav\x1d\xcd') # 0xca761dcd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.into_attack_speed))
data.write(b'l\n+\xc8') # 0x6c0a2bc8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.attack_speed))
data.write(b'u\xdb\xb3u') # 0x75dbb375
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.mass))
data.write(b'\xe1\xaeQ\xd8') # 0xe1ae51d8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.max_attack_height))
data.write(b'T\x0c\x1f\x87') # 0x540c1f87
data.write(b'\x00\x0c') # size
self.attack_aim_offset.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']),
actor_information=ActorParameters.from_json(data['actor_information']),
animation_information=AnimationParameters.from_json(data['animation_information']),
active=data['active'],
basic_swarm_properties=BasicSwarmProperties.from_json(data['basic_swarm_properties']),
unknown_0x7399abbb=data['unknown_0x7399abbb'],
unknown_0x734d923b=data['unknown_0x734d923b'],
max_attack_angle=data['max_attack_angle'],
into_attack_speed=data['into_attack_speed'],
attack_speed=data['attack_speed'],
mass=data['mass'],
max_attack_height=data['max_attack_height'],
attack_aim_offset=Vector.from_json(data['attack_aim_offset']),
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'actor_information': self.actor_information.to_json(),
'animation_information': self.animation_information.to_json(),
'active': self.active,
'basic_swarm_properties': self.basic_swarm_properties.to_json(),
'unknown_0x7399abbb': self.unknown_0x7399abbb,
'unknown_0x734d923b': self.unknown_0x734d923b,
'max_attack_angle': self.max_attack_angle,
'into_attack_speed': self.into_attack_speed,
'attack_speed': self.attack_speed,
'mass': self.mass,
'max_attack_height': self.max_attack_height,
'attack_aim_offset': self.attack_aim_offset.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_basic_swarm_properties(self, asset_manager):
yield from self.basic_swarm_properties.dependencies_for(asset_manager)
def _dependencies_for_unknown_0x7399abbb(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.unknown_0x7399abbb)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_basic_swarm_properties, "basic_swarm_properties", "BasicSwarmProperties"),
(self._dependencies_for_unknown_0x7399abbb, "unknown_0x7399abbb", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for IngBlobSwarm.{field_name} ({field_type}): {e}"
)
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_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_basic_swarm_properties(data: typing.BinaryIO, property_size: int):
return BasicSwarmProperties.from_stream(data, property_size)
def _decode_unknown_0x7399abbb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x734d923b(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_attack_angle(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_into_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_mass(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_max_attack_height(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_attack_aim_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x7e397fed: ('actor_information', _decode_actor_information),
0xe25fb08c: ('animation_information', _decode_animation_information),
0xc6bb2f45: ('active', _decode_active),
0xe1ec7346: ('basic_swarm_properties', _decode_basic_swarm_properties),
0x7399abbb: ('unknown_0x7399abbb', _decode_unknown_0x7399abbb),
0x734d923b: ('unknown_0x734d923b', _decode_unknown_0x734d923b),
0xf11f7384: ('max_attack_angle', _decode_max_attack_angle),
0xca761dcd: ('into_attack_speed', _decode_into_attack_speed),
0x6c0a2bc8: ('attack_speed', _decode_attack_speed),
0x75dbb375: ('mass', _decode_mass),
0xe1ae51d8: ('max_attack_height', _decode_max_attack_height),
0x540c1f87: ('attack_aim_offset', _decode_attack_aim_offset),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/IngBlobSwarm.py | 0.570212 | 0.308646 | IngBlobSwarm.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.SplineType import SplineType
from retro_data_structures.properties.echoes.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)
spline_type: SplineType = dataclasses.field(default_factory=SplineType)
unknown: bool = dataclasses.field(default=False)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
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\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'\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'3\xe4h[') # 0x33e4685b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.spline_type.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'C\x17i\xc6') # 0x431769c6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
forwards_pitch=Spline.from_json(data['forwards_pitch']),
backwards_pitch=Spline.from_json(data['backwards_pitch']),
spline_type=SplineType.from_json(data['spline_type']),
unknown=data['unknown'],
)
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(),
'spline_type': self.spline_type.to_json(),
'unknown': self.unknown,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_spline_type(self, asset_manager):
yield from self.spline_type.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_spline_type, "spline_type", "SplineType"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for CameraPitch.{field_name} ({field_type}): {e}"
)
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_spline_type(data: typing.BinaryIO, property_size: int):
return SplineType.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x81d093b3: ('forwards_pitch', _decode_forwards_pitch),
0xad9f8e3e: ('backwards_pitch', _decode_backwards_pitch),
0x33e4685b: ('spline_type', _decode_spline_type),
0x431769c6: ('unknown', _decode_unknown),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/CameraPitch.py | 0.61878 | 0.352369 | 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.echoes.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.ECHOES
def get_name(self) -> typing.Optional[str]:
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 _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Dock.{field_name} ({field_type}): {e}"
)
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/echoes/objects/Dock.py | 0.598077 | 0.324088 | 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.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Brizgee(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
patterned: PatternedAITypedef = dataclasses.field(default_factory=PatternedAITypedef)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
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=720.0)
down_turn_speed: float = dataclasses.field(default=120.0)
visible_distance: float = dataclasses.field(default=40.0)
forward_moving_priority: float = dataclasses.field(default=0.20000000298023224)
no_shell_model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
no_shell_skin: AssetId = dataclasses.field(metadata={'asset_types': ['CSKR']}, default=default_asset_id)
shell_vulnerability: DamageVulnerability = dataclasses.field(default_factory=DamageVulnerability)
shell_health: float = dataclasses.field(default=2.0)
shell_contact_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown: float = dataclasses.field(default=1.5)
poison_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
poison_time: float = dataclasses.field(default=2.0)
shell_break_sound: int = dataclasses.field(default=0, metadata={'sound': True})
poison_hit_sound: int = dataclasses.field(default=0, metadata={'sound': True})
player_poison_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'BRZG'
@classmethod
def modules(cls) -> typing.List[str]:
return ['WallCrawler.rel', 'Parasite.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x14') # 20 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\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'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'\xa7%0\xe8') # 0xa72530e8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.visible_distance))
data.write(b'^jT\xb8') # 0x5e6a54b8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.forward_moving_priority))
data.write(b'\x07\xf9G\xf4') # 0x7f947f4
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.no_shell_model))
data.write(b'\x0bs%\xea') # 0xb7325ea
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.no_shell_skin))
data.write(b'\xf5s\xe1\x1c') # 0xf573e11c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shell_vulnerability.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xaa\x13%:') # 0xaa13253a
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.shell_health))
data.write(b'\xb4\x82\xe5\xdd') # 0xb482e5dd
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.shell_contact_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\x80\xda\x80S') # 0x80da8053
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown))
data.write(b'\x14=\x18\xc6') # 0x143d18c6
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.poison_damage.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xf7\x89G\xd4') # 0xf78947d4
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.poison_time))
data.write(b'j\x94*`') # 0x6a942a60
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.shell_break_sound))
data.write(b'\x80\x83\x92\xec') # 0x808392ec
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.poison_hit_sound))
data.write(b'\xdf-\x80\x17') # 0xdf2d8017
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.player_poison_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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
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'],
visible_distance=data['visible_distance'],
forward_moving_priority=data['forward_moving_priority'],
no_shell_model=data['no_shell_model'],
no_shell_skin=data['no_shell_skin'],
shell_vulnerability=DamageVulnerability.from_json(data['shell_vulnerability']),
shell_health=data['shell_health'],
shell_contact_damage=DamageInfo.from_json(data['shell_contact_damage']),
unknown=data['unknown'],
poison_damage=DamageInfo.from_json(data['poison_damage']),
poison_time=data['poison_time'],
shell_break_sound=data['shell_break_sound'],
poison_hit_sound=data['poison_hit_sound'],
player_poison_sound=data['player_poison_sound'],
)
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(),
'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,
'visible_distance': self.visible_distance,
'forward_moving_priority': self.forward_moving_priority,
'no_shell_model': self.no_shell_model,
'no_shell_skin': self.no_shell_skin,
'shell_vulnerability': self.shell_vulnerability.to_json(),
'shell_health': self.shell_health,
'shell_contact_damage': self.shell_contact_damage.to_json(),
'unknown': self.unknown,
'poison_damage': self.poison_damage.to_json(),
'poison_time': self.poison_time,
'shell_break_sound': self.shell_break_sound,
'poison_hit_sound': self.poison_hit_sound,
'player_poison_sound': self.player_poison_sound,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_no_shell_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.no_shell_model)
def _dependencies_for_no_shell_skin(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.no_shell_skin)
def _dependencies_for_shell_vulnerability(self, asset_manager):
yield from self.shell_vulnerability.dependencies_for(asset_manager)
def _dependencies_for_shell_contact_damage(self, asset_manager):
yield from self.shell_contact_damage.dependencies_for(asset_manager)
def _dependencies_for_poison_damage(self, asset_manager):
yield from self.poison_damage.dependencies_for(asset_manager)
def _dependencies_for_shell_break_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.shell_break_sound)
def _dependencies_for_poison_hit_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.poison_hit_sound)
def _dependencies_for_player_poison_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.player_poison_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_no_shell_model, "no_shell_model", "AssetId"),
(self._dependencies_for_no_shell_skin, "no_shell_skin", "AssetId"),
(self._dependencies_for_shell_vulnerability, "shell_vulnerability", "DamageVulnerability"),
(self._dependencies_for_shell_contact_damage, "shell_contact_damage", "DamageInfo"),
(self._dependencies_for_poison_damage, "poison_damage", "DamageInfo"),
(self._dependencies_for_shell_break_sound, "shell_break_sound", "int"),
(self._dependencies_for_poison_hit_sound, "poison_hit_sound", "int"),
(self._dependencies_for_player_poison_sound, "player_poison_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Brizgee.{field_name} ({field_type}): {e}"
)
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_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_visible_distance(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_no_shell_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_no_shell_skin(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_shell_vulnerability(data: typing.BinaryIO, property_size: int):
return DamageVulnerability.from_stream(data, property_size)
def _decode_shell_health(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shell_contact_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_unknown(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_poison_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size)
def _decode_poison_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_shell_break_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_poison_hit_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_player_poison_sound(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
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),
0xa72530e8: ('visible_distance', _decode_visible_distance),
0x5e6a54b8: ('forward_moving_priority', _decode_forward_moving_priority),
0x7f947f4: ('no_shell_model', _decode_no_shell_model),
0xb7325ea: ('no_shell_skin', _decode_no_shell_skin),
0xf573e11c: ('shell_vulnerability', _decode_shell_vulnerability),
0xaa13253a: ('shell_health', _decode_shell_health),
0xb482e5dd: ('shell_contact_damage', _decode_shell_contact_damage),
0x80da8053: ('unknown', _decode_unknown),
0x143d18c6: ('poison_damage', _decode_poison_damage),
0xf78947d4: ('poison_time', _decode_poison_time),
0x6a942a60: ('shell_break_sound', _decode_shell_break_sound),
0x808392ec: ('poison_hit_sound', _decode_poison_hit_sound),
0xdf2d8017: ('player_poison_sound', _decode_player_poison_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Brizgee.py | 0.584034 | 0.288456 | Brizgee.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Color import Color
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class DebrisExtended(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
cone_spread: float = dataclasses.field(default=180.0)
movement_direction: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=1.0))
minimum_speed: float = dataclasses.field(default=5.0)
maximum_speed: float = dataclasses.field(default=15.0)
minimum_spin_speed: float = dataclasses.field(default=1.0)
maximum_spin_speed: float = dataclasses.field(default=1.2000000476837158)
minimum_life_time: float = dataclasses.field(default=2.0)
maximum_life_time: float = dataclasses.field(default=3.0)
disable_collision_time: float = dataclasses.field(default=0.0)
fade_in_end_percentage: float = dataclasses.field(default=10.0)
fade_out_start_percentage: float = dataclasses.field(default=80.0)
start_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
end_color: Color = dataclasses.field(default_factory=lambda: Color(r=1.0, g=1.0, b=1.0, a=0.0))
scale_start_percentage: float = dataclasses.field(default=80.0)
final_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
unknown_0x417f4a91: float = dataclasses.field(default=0.375)
gravity: float = dataclasses.field(default=25.0)
position_offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
model: AssetId = dataclasses.field(metadata={'asset_types': ['CMDL']}, default=default_asset_id)
actor_information: ActorParameters = dataclasses.field(default_factory=ActorParameters)
particle1: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
bounce_sound: int = dataclasses.field(default=0, metadata={'sound': True})
max_bounce_sounds: int = dataclasses.field(default=1)
unknown_0x76c79503: float = dataclasses.field(default=1.0)
unknown_0x310dfac8: float = dataclasses.field(default=1.0)
particle_system1_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system1_uses_global_translation: bool = dataclasses.field(default=False)
particle_system1_wait_for_particles_to_die: bool = dataclasses.field(default=False)
particle_system1_orientation: int = dataclasses.field(default=0) # Choice
particle2: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
particle_system2_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
particle_system2_uses_global_translation: bool = dataclasses.field(default=False)
particle_system2_wait_for_particles_to_die: bool = dataclasses.field(default=False)
particle_system2_orientation: int = dataclasses.field(default=0) # Choice
death_particle: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
death_particle_system_scale: Vector = dataclasses.field(default_factory=lambda: Vector(x=1.0, y=1.0, z=1.0))
death_particle_system_orientation: int = dataclasses.field(default=0) # Choice
is_collider: bool = dataclasses.field(default=True)
is_shootable: bool = dataclasses.field(default=False)
die_on_collision: bool = dataclasses.field(default=False)
unknown_0xdcaa0f22: bool = dataclasses.field(default=False)
unknown_0xbfd82a19: bool = dataclasses.field(default=False)
unknown_0x723d42d6: bool = dataclasses.field(default=True)
unknown_0x4edb1d0e: bool = dataclasses.field(default=False)
disable_physics_threshold: float = dataclasses.field(default=1.0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'DBR2'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00.') # 46 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'\x8do\xc3\x91') # 0x8d6fc391
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.cone_spread))
data.write(b'\x80u\xf8\xf8') # 0x8075f8f8
data.write(b'\x00\x0c') # size
self.movement_direction.to_stream(data)
data.write(b'\x01\x85&>') # 0x185263e
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_speed))
data.write(b'\x14\x0e\xf2\xcc') # 0x140ef2cc
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_speed))
data.write(b'\x86>\xbbv') # 0x863ebb76
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_spin_speed))
data.write(b'\x95{]\xdd') # 0x957b5ddd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_spin_speed))
data.write(b'T\xa8\xc4\x81') # 0x54a8c481
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.minimum_life_time))
data.write(b'}\xd69\x99') # 0x7dd63999
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.maximum_life_time))
data.write(b'kW\x1b\xa5') # 0x6b571ba5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_collision_time))
data.write(b'P\x05\x1a\x17') # 0x50051a17
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_in_end_percentage))
data.write(b'cS\xc4\t') # 0x6353c409
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.fade_out_start_percentage))
data.write(b':V4\xd8') # 0x3a5634d8
data.write(b'\x00\x10') # size
self.start_color.to_stream(data)
data.write(b'Z\xf5\x86}') # 0x5af5867d
data.write(b'\x00\x10') # size
self.end_color.to_stream(data)
data.write(b'\x88n|\x9f') # 0x886e7c9f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.scale_start_percentage))
data.write(b'\x80\xc2*\n') # 0x80c22a0a
data.write(b'\x00\x0c') # size
self.final_scale.to_stream(data)
data.write(b'A\x7fJ\x91') # 0x417f4a91
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x417f4a91))
data.write(b'/*\xe3\xe5') # 0x2f2ae3e5
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.gravity))
data.write(b'\xef\x90\xf0\x9d') # 0xef90f09d
data.write(b'\x00\x0c') # size
self.position_offset.to_stream(data)
data.write(b'\xc2\x7f\xfa\x8f') # 0xc27ffa8f
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.model))
data.write(b'~9\x7f\xed') # 0x7e397fed
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.actor_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'A\xddM@') # 0x41dd4d40
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle1))
data.write(b'\x0b\xb3\xcc\xae') # 0xbb3ccae
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.bounce_sound))
data.write(b'\x99\x12\x02\xc3') # 0x991202c3
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.max_bounce_sounds))
data.write(b'v\xc7\x95\x03') # 0x76c79503
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x76c79503))
data.write(b'1\r\xfa\xc8') # 0x310dfac8
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x310dfac8))
data.write(b'\x19\xa6\xf7\x1f') # 0x19a6f71f
data.write(b'\x00\x0c') # size
self.particle_system1_scale.to_stream(data)
data.write(b';\x03\xa0\x1e') # 0x3b03a01e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_uses_global_translation))
data.write(b';\xdd/\xed') # 0x3bdd2fed
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system1_wait_for_particles_to_die))
data.write(b'3J4\xbb') # 0x334a34bb
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle_system1_orientation))
data.write(b'\xc7I?\xee') # 0xc7493fee
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle2))
data.write(b'n8%\xef') # 0x6e3825ef
data.write(b'\x00\x0c') # size
self.particle_system2_scale.to_stream(data)
data.write(b'\xc9TM\xe6') # 0xc9544de6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_uses_global_translation))
data.write(b'\xc9\x8a\xc2\x15') # 0xc98ac215
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.particle_system2_wait_for_particles_to_die))
data.write(b'\xd9\xcc\xe9\xd9') # 0xd9cce9d9
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.particle_system2_orientation))
data.write(b'\x97\x90B\xc8') # 0x979042c8
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_particle))
data.write(b'\xe9!L\xd8') # 0xe9214cd8
data.write(b'\x00\x0c') # size
self.death_particle_system_scale.to_stream(data)
data.write(b'\x9d\xfa\xde\xe0') # 0x9dfadee0
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.death_particle_system_orientation))
data.write(b',{\x18\xdd') # 0x2c7b18dd
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_collider))
data.write(b'\x8cs\xcb|') # 0x8c73cb7c
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.is_shootable))
data.write(b'\r\x7f\xadU') # 0xd7fad55
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.die_on_collision))
data.write(b'\xdc\xaa\x0f"') # 0xdcaa0f22
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xdcaa0f22))
data.write(b'\xbf\xd8*\x19') # 0xbfd82a19
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0xbfd82a19))
data.write(b'r=B\xd6') # 0x723d42d6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x723d42d6))
data.write(b'N\xdb\x1d\x0e') # 0x4edb1d0e
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.unknown_0x4edb1d0e))
data.write(b')_\x05\xb7') # 0x295f05b7
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.disable_physics_threshold))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
cone_spread=data['cone_spread'],
movement_direction=Vector.from_json(data['movement_direction']),
minimum_speed=data['minimum_speed'],
maximum_speed=data['maximum_speed'],
minimum_spin_speed=data['minimum_spin_speed'],
maximum_spin_speed=data['maximum_spin_speed'],
minimum_life_time=data['minimum_life_time'],
maximum_life_time=data['maximum_life_time'],
disable_collision_time=data['disable_collision_time'],
fade_in_end_percentage=data['fade_in_end_percentage'],
fade_out_start_percentage=data['fade_out_start_percentage'],
start_color=Color.from_json(data['start_color']),
end_color=Color.from_json(data['end_color']),
scale_start_percentage=data['scale_start_percentage'],
final_scale=Vector.from_json(data['final_scale']),
unknown_0x417f4a91=data['unknown_0x417f4a91'],
gravity=data['gravity'],
position_offset=Vector.from_json(data['position_offset']),
model=data['model'],
actor_information=ActorParameters.from_json(data['actor_information']),
particle1=data['particle1'],
bounce_sound=data['bounce_sound'],
max_bounce_sounds=data['max_bounce_sounds'],
unknown_0x76c79503=data['unknown_0x76c79503'],
unknown_0x310dfac8=data['unknown_0x310dfac8'],
particle_system1_scale=Vector.from_json(data['particle_system1_scale']),
particle_system1_uses_global_translation=data['particle_system1_uses_global_translation'],
particle_system1_wait_for_particles_to_die=data['particle_system1_wait_for_particles_to_die'],
particle_system1_orientation=data['particle_system1_orientation'],
particle2=data['particle2'],
particle_system2_scale=Vector.from_json(data['particle_system2_scale']),
particle_system2_uses_global_translation=data['particle_system2_uses_global_translation'],
particle_system2_wait_for_particles_to_die=data['particle_system2_wait_for_particles_to_die'],
particle_system2_orientation=data['particle_system2_orientation'],
death_particle=data['death_particle'],
death_particle_system_scale=Vector.from_json(data['death_particle_system_scale']),
death_particle_system_orientation=data['death_particle_system_orientation'],
is_collider=data['is_collider'],
is_shootable=data['is_shootable'],
die_on_collision=data['die_on_collision'],
unknown_0xdcaa0f22=data['unknown_0xdcaa0f22'],
unknown_0xbfd82a19=data['unknown_0xbfd82a19'],
unknown_0x723d42d6=data['unknown_0x723d42d6'],
unknown_0x4edb1d0e=data['unknown_0x4edb1d0e'],
disable_physics_threshold=data['disable_physics_threshold'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'cone_spread': self.cone_spread,
'movement_direction': self.movement_direction.to_json(),
'minimum_speed': self.minimum_speed,
'maximum_speed': self.maximum_speed,
'minimum_spin_speed': self.minimum_spin_speed,
'maximum_spin_speed': self.maximum_spin_speed,
'minimum_life_time': self.minimum_life_time,
'maximum_life_time': self.maximum_life_time,
'disable_collision_time': self.disable_collision_time,
'fade_in_end_percentage': self.fade_in_end_percentage,
'fade_out_start_percentage': self.fade_out_start_percentage,
'start_color': self.start_color.to_json(),
'end_color': self.end_color.to_json(),
'scale_start_percentage': self.scale_start_percentage,
'final_scale': self.final_scale.to_json(),
'unknown_0x417f4a91': self.unknown_0x417f4a91,
'gravity': self.gravity,
'position_offset': self.position_offset.to_json(),
'model': self.model,
'actor_information': self.actor_information.to_json(),
'particle1': self.particle1,
'bounce_sound': self.bounce_sound,
'max_bounce_sounds': self.max_bounce_sounds,
'unknown_0x76c79503': self.unknown_0x76c79503,
'unknown_0x310dfac8': self.unknown_0x310dfac8,
'particle_system1_scale': self.particle_system1_scale.to_json(),
'particle_system1_uses_global_translation': self.particle_system1_uses_global_translation,
'particle_system1_wait_for_particles_to_die': self.particle_system1_wait_for_particles_to_die,
'particle_system1_orientation': self.particle_system1_orientation,
'particle2': self.particle2,
'particle_system2_scale': self.particle_system2_scale.to_json(),
'particle_system2_uses_global_translation': self.particle_system2_uses_global_translation,
'particle_system2_wait_for_particles_to_die': self.particle_system2_wait_for_particles_to_die,
'particle_system2_orientation': self.particle_system2_orientation,
'death_particle': self.death_particle,
'death_particle_system_scale': self.death_particle_system_scale.to_json(),
'death_particle_system_orientation': self.death_particle_system_orientation,
'is_collider': self.is_collider,
'is_shootable': self.is_shootable,
'die_on_collision': self.die_on_collision,
'unknown_0xdcaa0f22': self.unknown_0xdcaa0f22,
'unknown_0xbfd82a19': self.unknown_0xbfd82a19,
'unknown_0x723d42d6': self.unknown_0x723d42d6,
'unknown_0x4edb1d0e': self.unknown_0x4edb1d0e,
'disable_physics_threshold': self.disable_physics_threshold,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_model(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.model)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_particle1(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle1)
def _dependencies_for_bounce_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.bounce_sound)
def _dependencies_for_particle2(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.particle2)
def _dependencies_for_death_particle(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.death_particle)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_model, "model", "AssetId"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_particle1, "particle1", "AssetId"),
(self._dependencies_for_bounce_sound, "bounce_sound", "int"),
(self._dependencies_for_particle2, "particle2", "AssetId"),
(self._dependencies_for_death_particle, "death_particle", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for DebrisExtended.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size, default_override={'active': False})
def _decode_cone_spread(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_movement_direction(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_minimum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_spin_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_spin_speed(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_minimum_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_maximum_life_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_disable_collision_time(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_in_end_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_fade_out_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_start_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_end_color(data: typing.BinaryIO, property_size: int):
return Color.from_stream(data)
def _decode_scale_start_percentage(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_final_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_unknown_0x417f4a91(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_position_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_model(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_particle1(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_bounce_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_max_bounce_sounds(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0x76c79503(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x310dfac8(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_particle_system1_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system1_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system1_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_particle2(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_particle_system2_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_particle_system2_uses_global_translation(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_wait_for_particles_to_die(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_particle_system2_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_particle(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_death_particle_system_scale(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_death_particle_system_orientation(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_is_collider(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_is_shootable(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_die_on_collision(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xdcaa0f22(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0xbfd82a19(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x723d42d6(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_unknown_0x4edb1d0e(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_disable_physics_threshold(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0x8d6fc391: ('cone_spread', _decode_cone_spread),
0x8075f8f8: ('movement_direction', _decode_movement_direction),
0x185263e: ('minimum_speed', _decode_minimum_speed),
0x140ef2cc: ('maximum_speed', _decode_maximum_speed),
0x863ebb76: ('minimum_spin_speed', _decode_minimum_spin_speed),
0x957b5ddd: ('maximum_spin_speed', _decode_maximum_spin_speed),
0x54a8c481: ('minimum_life_time', _decode_minimum_life_time),
0x7dd63999: ('maximum_life_time', _decode_maximum_life_time),
0x6b571ba5: ('disable_collision_time', _decode_disable_collision_time),
0x50051a17: ('fade_in_end_percentage', _decode_fade_in_end_percentage),
0x6353c409: ('fade_out_start_percentage', _decode_fade_out_start_percentage),
0x3a5634d8: ('start_color', _decode_start_color),
0x5af5867d: ('end_color', _decode_end_color),
0x886e7c9f: ('scale_start_percentage', _decode_scale_start_percentage),
0x80c22a0a: ('final_scale', _decode_final_scale),
0x417f4a91: ('unknown_0x417f4a91', _decode_unknown_0x417f4a91),
0x2f2ae3e5: ('gravity', _decode_gravity),
0xef90f09d: ('position_offset', _decode_position_offset),
0xc27ffa8f: ('model', _decode_model),
0x7e397fed: ('actor_information', _decode_actor_information),
0x41dd4d40: ('particle1', _decode_particle1),
0xbb3ccae: ('bounce_sound', _decode_bounce_sound),
0x991202c3: ('max_bounce_sounds', _decode_max_bounce_sounds),
0x76c79503: ('unknown_0x76c79503', _decode_unknown_0x76c79503),
0x310dfac8: ('unknown_0x310dfac8', _decode_unknown_0x310dfac8),
0x19a6f71f: ('particle_system1_scale', _decode_particle_system1_scale),
0x3b03a01e: ('particle_system1_uses_global_translation', _decode_particle_system1_uses_global_translation),
0x3bdd2fed: ('particle_system1_wait_for_particles_to_die', _decode_particle_system1_wait_for_particles_to_die),
0x334a34bb: ('particle_system1_orientation', _decode_particle_system1_orientation),
0xc7493fee: ('particle2', _decode_particle2),
0x6e3825ef: ('particle_system2_scale', _decode_particle_system2_scale),
0xc9544de6: ('particle_system2_uses_global_translation', _decode_particle_system2_uses_global_translation),
0xc98ac215: ('particle_system2_wait_for_particles_to_die', _decode_particle_system2_wait_for_particles_to_die),
0xd9cce9d9: ('particle_system2_orientation', _decode_particle_system2_orientation),
0x979042c8: ('death_particle', _decode_death_particle),
0xe9214cd8: ('death_particle_system_scale', _decode_death_particle_system_scale),
0x9dfadee0: ('death_particle_system_orientation', _decode_death_particle_system_orientation),
0x2c7b18dd: ('is_collider', _decode_is_collider),
0x8c73cb7c: ('is_shootable', _decode_is_shootable),
0xd7fad55: ('die_on_collision', _decode_die_on_collision),
0xdcaa0f22: ('unknown_0xdcaa0f22', _decode_unknown_0xdcaa0f22),
0xbfd82a19: ('unknown_0xbfd82a19', _decode_unknown_0xbfd82a19),
0x723d42d6: ('unknown_0x723d42d6', _decode_unknown_0x723d42d6),
0x4edb1d0e: ('unknown_0x4edb1d0e', _decode_unknown_0x4edb1d0e),
0x295f05b7: ('disable_physics_threshold', _decode_disable_physics_threshold),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/DebrisExtended.py | 0.708818 | 0.241903 | DebrisExtended.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
from retro_data_structures.properties.echoes.core.Vector import Vector
@dataclasses.dataclass()
class PickupGenerator(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
offset: Vector = dataclasses.field(default_factory=lambda: Vector(x=0.0, y=0.0, z=0.0))
offset_is_local_space: bool = dataclasses.field(default=False)
rules: AssetId = dataclasses.field(metadata={'asset_types': ['RULE']}, default=default_asset_id)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'PKGN'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'FGpd') # 0x46477064
data.write(b'\x00\x0c') # size
self.offset.to_stream(data)
data.write(b'r\xbb\xe7\xa6') # 0x72bbe7a6
data.write(b'\x00\x01') # size
data.write(struct.pack('>?', self.offset_is_local_space))
data.write(b'\x0cQC\xfe') # 0xc5143fe
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.rules))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
offset=Vector.from_json(data['offset']),
offset_is_local_space=data['offset_is_local_space'],
rules=data['rules'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'offset': self.offset.to_json(),
'offset_is_local_space': self.offset_is_local_space,
'rules': self.rules,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_rules(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.rules)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_rules, "rules", "AssetId"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for PickupGenerator.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_offset(data: typing.BinaryIO, property_size: int):
return Vector.from_stream(data)
def _decode_offset_is_local_space(data: typing.BinaryIO, property_size: int):
return struct.unpack('>?', data.read(1))[0]
def _decode_rules(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),
0x46477064: ('offset', _decode_offset),
0x72bbe7a6: ('offset_is_local_space', _decode_offset_is_local_space),
0xc5143fe: ('rules', _decode_rules),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/PickupGenerator.py | 0.594551 | 0.335228 | PickupGenerator.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
@dataclasses.dataclass()
class AIJumpPoint(BaseObjectType):
editor_properties: EditorProperties = dataclasses.field(default_factory=EditorProperties)
jump_apex: float = dataclasses.field(default=3.0)
type: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'AJMP'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\xf2x%\x01') # 0xf2782501
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.jump_apex))
data.write(b'\xf5=\xcd\xd6') # 0xf53dcdd6
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.type))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_offset - 2))
data.seek(struct_end_offset)
@classmethod
def from_json(cls, data: dict):
return cls(
editor_properties=EditorProperties.from_json(data['editor_properties']),
jump_apex=data['jump_apex'],
type=data['type'],
)
def to_json(self) -> dict:
return {
'editor_properties': self.editor_properties.to_json(),
'jump_apex': self.jump_apex,
'type': self.type,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AIJumpPoint.{field_name} ({field_type}): {e}"
)
def _decode_editor_properties(data: typing.BinaryIO, property_size: int):
return EditorProperties.from_stream(data, property_size)
def _decode_jump_apex(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_type(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
_property_decoder: typing.Dict[int, typing.Tuple[str, typing.Callable[[typing.BinaryIO, int], typing.Any]]] = {
0x255a4580: ('editor_properties', _decode_editor_properties),
0xf2782501: ('jump_apex', _decode_jump_apex),
0xf53dcdd6: ('type', _decode_type),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AIJumpPoint.py | 0.630457 | 0.378459 | AIJumpPoint.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
@dataclasses.dataclass()
class TweakParticle(BaseObjectType):
instance_name: str = dataclasses.field(default='')
pak_file: str = dataclasses.field(default='')
primary_weapon: str = dataclasses.field(default='')
secondary_weapon: str = dataclasses.field(default='')
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return None
def set_name(self, name: str) -> None:
raise RuntimeError(f"{self.__class__.__name__} does not have name")
@classmethod
def object_type(cls) -> str:
return 'TWPA'
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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'\x7f\xda\x14f') # 0x7fda1466
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.instance_name.encode("utf-8"))
data.write(b'\x00')
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'+\xd1:\xb3') # 0x2bd13ab3
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.pak_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'^\x15\x86\x8a') # 0x5e15868a
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.primary_weapon.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'\xbc@\x14E') # 0xbc401445
before = data.tell()
data.write(b'\x00\x00') # size placeholder
data.write(self.secondary_weapon.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(
instance_name=data['instance_name'],
pak_file=data['pak_file'],
primary_weapon=data['primary_weapon'],
secondary_weapon=data['secondary_weapon'],
)
def to_json(self) -> dict:
return {
'instance_name': self.instance_name,
'pak_file': self.pak_file,
'primary_weapon': self.primary_weapon,
'secondary_weapon': self.secondary_weapon,
}
def dependencies_for(self, asset_manager):
yield from []
def _decode_instance_name(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_pak_file(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_primary_weapon(data: typing.BinaryIO, property_size: int):
return b"".join(iter(lambda: data.read(1), b'\x00')).decode("utf-8")
def _decode_secondary_weapon(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]]] = {
0x7fda1466: ('instance_name', _decode_instance_name),
0x2bd13ab3: ('pak_file', _decode_pak_file),
0x5e15868a: ('primary_weapon', _decode_primary_weapon),
0xbc401445: ('secondary_weapon', _decode_secondary_weapon),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/TweakParticle.py | 0.585694 | 0.324449 | TweakParticle.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.archetypes.UnknownStruct37 import UnknownStruct37
@dataclasses.dataclass()
class SwampBossStage1(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_struct37: UnknownStruct37 = dataclasses.field(default_factory=UnknownStruct37)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'SBS1'
@classmethod
def modules(cls) -> typing.List[str]:
return ['SwampBossStage1.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\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': 2})
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'\xb0\x1a(\xd5') # 0xb01a28d5
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.unknown_struct37.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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_struct37=UnknownStruct37.from_json(data['unknown_struct37']),
)
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_struct37': self.unknown_struct37.to_json(),
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_unknown_struct37(self, asset_manager):
yield from self.unknown_struct37.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_unknown_struct37, "unknown_struct37", "UnknownStruct37"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for SwampBossStage1.{field_name} ({field_type}): {e}"
)
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': 2})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_struct37(data: typing.BinaryIO, property_size: int):
return UnknownStruct37.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),
0xb01a28d5: ('unknown_struct37', _decode_unknown_struct37),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/SwampBossStage1.py | 0.634204 | 0.368122 | SwampBossStage1.py | pypi |
import dataclasses
import struct
import typing
from retro_data_structures.game_check import Game
from retro_data_structures.properties.base_property import BaseObjectType
from retro_data_structures.properties.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageVulnerability import DamageVulnerability
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.HealthInfo import HealthInfo
from retro_data_structures.properties.echoes.core.AnimationParameters import AnimationParameters
from retro_data_structures.properties.echoes.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)
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_0xbfe017de: int = dataclasses.field(default=0)
unknown_0xed5f16ac: int = dataclasses.field(default=0)
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
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'\xe2_\xb0\x8c') # 0xe25fb08c
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.animation_information.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
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'\xbf\xe0\x17\xde') # 0xbfe017de
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xbfe017de))
data.write(b'\xed_\x16\xac') # 0xed5f16ac
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.unknown_0xed5f16ac))
struct_end_offset = data.tell()
data.seek(root_size_offset)
data.write(struct.pack(">H", struct_end_offset - root_size_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']),
animation_information=AnimationParameters.from_json(data['animation_information']),
actor_information=ActorParameters.from_json(data['actor_information']),
detect_radius=data['detect_radius'],
explode_radius=data['explode_radius'],
unknown_0xbfe017de=data['unknown_0xbfe017de'],
unknown_0xed5f16ac=data['unknown_0xed5f16ac'],
)
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(),
'animation_information': self.animation_information.to_json(),
'actor_information': self.actor_information.to_json(),
'detect_radius': self.detect_radius,
'explode_radius': self.explode_radius,
'unknown_0xbfe017de': self.unknown_0xbfe017de,
'unknown_0xed5f16ac': self.unknown_0xed5f16ac,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_health(self, asset_manager):
yield from self.health.dependencies_for(asset_manager)
def _dependencies_for_vulnerability(self, asset_manager):
yield from self.vulnerability.dependencies_for(asset_manager)
def _dependencies_for_animation_information(self, asset_manager):
yield from self.animation_information.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_health, "health", "HealthInfo"),
(self._dependencies_for_vulnerability, "vulnerability", "DamageVulnerability"),
(self._dependencies_for_animation_information, "animation_information", "AnimationParameters"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for AmbientAI.{field_name} ({field_type}): {e}"
)
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_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_0xbfe017de(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_unknown_0xed5f16ac(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),
0xe25fb08c: ('animation_information', _decode_animation_information),
0x7e397fed: ('actor_information', _decode_actor_information),
0xa7d00780: ('detect_radius', _decode_detect_radius),
0xd4d52631: ('explode_radius', _decode_explode_radius),
0xbfe017de: ('unknown_0xbfe017de', _decode_unknown_0xbfe017de),
0xed5f16ac: ('unknown_0xed5f16ac', _decode_unknown_0xed5f16ac),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/AmbientAI.py | 0.545044 | 0.348202 | 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.echoes.archetypes.ActorParameters import ActorParameters
from retro_data_structures.properties.echoes.archetypes.DamageInfo import DamageInfo
from retro_data_structures.properties.echoes.archetypes.EditorProperties import EditorProperties
from retro_data_structures.properties.echoes.archetypes.PatternedAITypedef import PatternedAITypedef
from retro_data_structures.properties.echoes.core.AssetId import AssetId, default_asset_id
@dataclasses.dataclass()
class Lumite(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_0x2d9ebd7f: float = dataclasses.field(default=8.0)
unknown_0x6dd1c509: float = dataclasses.field(default=30.0)
small_shot_projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
small_shot_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
unknown_0x6d5356bb: float = dataclasses.field(default=8.0)
unknown_0x2d1c2ecd: float = dataclasses.field(default=30.0)
big_shot_projectile: AssetId = dataclasses.field(metadata={'asset_types': ['WPSC']}, default=default_asset_id)
big_shot_damage: DamageInfo = dataclasses.field(default_factory=DamageInfo)
trail_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
sunlight_enter_exit_effect: AssetId = dataclasses.field(metadata={'asset_types': ['PART']}, default=default_asset_id)
unknown_0xe05d93ef: float = dataclasses.field(default=5.0)
unknown_0x47691396: float = dataclasses.field(default=45.0)
phase_in_sound: int = dataclasses.field(default=0, metadata={'sound': True})
phase_out_sound: int = dataclasses.field(default=0, metadata={'sound': True})
@classmethod
def game(cls) -> Game:
return Game.ECHOES
def get_name(self) -> typing.Optional[str]:
return self.editor_properties.name
def set_name(self, name: str) -> None:
self.editor_properties.name = name
@classmethod
def object_type(cls) -> str:
return 'LUMI'
@classmethod
def modules(cls) -> typing.List[str]:
return ['Lumite.rel']
@classmethod
def from_stream(cls, data: typing.BinaryIO, size: typing.Optional[int] = None, default_override: typing.Optional[dict] = None):
struct_id, size, property_count = struct.unpack(">LHH", data.read(8))
assert struct_id == 0xFFFFFFFF
root_size_start = data.tell() - 2
present_fields = default_override or {}
for _ in range(property_count):
property_id, property_size = struct.unpack(">LH", data.read(6))
start = data.tell()
try:
property_name, decoder = _property_decoder[property_id]
present_fields[property_name] = decoder(data, property_size)
except KeyError:
raise RuntimeError(f"Unknown property: 0x{property_id:08x}")
assert data.tell() - start == property_size
assert data.tell() - root_size_start == size
return cls(**present_fields)
def to_stream(self, data: typing.BinaryIO, default_override: typing.Optional[dict] = None):
default_override = default_override or {}
data.write(b'\xff\xff\xff\xff') # struct object id
root_size_offset = data.tell()
data.write(b'\x00\x00') # placeholder for root struct size
data.write(b'\x00\x11') # 17 properties
data.write(b'%ZE\x80') # 0x255a4580
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.editor_properties.to_stream(data)
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'\xb3wGP') # 0xb3774750
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.patterned.to_stream(data, default_override={'leash_radius': 100.0, 'collision_radius': 0.10000000149011612, 'collision_height': 0.10000000149011612, 'step_up_height': 1.0, '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'-\x9e\xbd\x7f') # 0x2d9ebd7f
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2d9ebd7f))
data.write(b'm\xd1\xc5\t') # 0x6dd1c509
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6dd1c509))
data.write(b'H\x15tS') # 0x48157453
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.small_shot_projectile))
data.write(b's\x07\xc3k') # 0x7307c36b
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.small_shot_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'mSV\xbb') # 0x6d5356bb
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x6d5356bb))
data.write(b'-\x1c.\xcd') # 0x2d1c2ecd
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x2d1c2ecd))
data.write(b'\xd0[\x1d$') # 0xd05b1d24
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.big_shot_projectile))
data.write(b'\xbd\xfei\x9d') # 0xbdfe699d
before = data.tell()
data.write(b'\x00\x00') # size placeholder
self.big_shot_damage.to_stream(data, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
after = data.tell()
data.seek(before)
data.write(struct.pack(">H", after - before - 2))
data.seek(after)
data.write(b'6\xee\xe7\x91') # 0x36eee791
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.trail_effect))
data.write(b'\xd2\x87\x9e\xbb') # 0xd2879ebb
data.write(b'\x00\x04') # size
data.write(struct.pack(">L", self.sunlight_enter_exit_effect))
data.write(b'\xe0]\x93\xef') # 0xe05d93ef
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0xe05d93ef))
data.write(b'Gi\x13\x96') # 0x47691396
data.write(b'\x00\x04') # size
data.write(struct.pack('>f', self.unknown_0x47691396))
data.write(b'\xa4#\x13#') # 0xa4231323
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.phase_in_sound))
data.write(b':\xafxq') # 0x3aaf7871
data.write(b'\x00\x04') # size
data.write(struct.pack('>l', self.phase_out_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']),
patterned=PatternedAITypedef.from_json(data['patterned']),
actor_information=ActorParameters.from_json(data['actor_information']),
unknown_0x2d9ebd7f=data['unknown_0x2d9ebd7f'],
unknown_0x6dd1c509=data['unknown_0x6dd1c509'],
small_shot_projectile=data['small_shot_projectile'],
small_shot_damage=DamageInfo.from_json(data['small_shot_damage']),
unknown_0x6d5356bb=data['unknown_0x6d5356bb'],
unknown_0x2d1c2ecd=data['unknown_0x2d1c2ecd'],
big_shot_projectile=data['big_shot_projectile'],
big_shot_damage=DamageInfo.from_json(data['big_shot_damage']),
trail_effect=data['trail_effect'],
sunlight_enter_exit_effect=data['sunlight_enter_exit_effect'],
unknown_0xe05d93ef=data['unknown_0xe05d93ef'],
unknown_0x47691396=data['unknown_0x47691396'],
phase_in_sound=data['phase_in_sound'],
phase_out_sound=data['phase_out_sound'],
)
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_0x2d9ebd7f': self.unknown_0x2d9ebd7f,
'unknown_0x6dd1c509': self.unknown_0x6dd1c509,
'small_shot_projectile': self.small_shot_projectile,
'small_shot_damage': self.small_shot_damage.to_json(),
'unknown_0x6d5356bb': self.unknown_0x6d5356bb,
'unknown_0x2d1c2ecd': self.unknown_0x2d1c2ecd,
'big_shot_projectile': self.big_shot_projectile,
'big_shot_damage': self.big_shot_damage.to_json(),
'trail_effect': self.trail_effect,
'sunlight_enter_exit_effect': self.sunlight_enter_exit_effect,
'unknown_0xe05d93ef': self.unknown_0xe05d93ef,
'unknown_0x47691396': self.unknown_0x47691396,
'phase_in_sound': self.phase_in_sound,
'phase_out_sound': self.phase_out_sound,
}
def _dependencies_for_editor_properties(self, asset_manager):
yield from self.editor_properties.dependencies_for(asset_manager)
def _dependencies_for_patterned(self, asset_manager):
yield from self.patterned.dependencies_for(asset_manager)
def _dependencies_for_actor_information(self, asset_manager):
yield from self.actor_information.dependencies_for(asset_manager)
def _dependencies_for_small_shot_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.small_shot_projectile)
def _dependencies_for_small_shot_damage(self, asset_manager):
yield from self.small_shot_damage.dependencies_for(asset_manager)
def _dependencies_for_big_shot_projectile(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.big_shot_projectile)
def _dependencies_for_big_shot_damage(self, asset_manager):
yield from self.big_shot_damage.dependencies_for(asset_manager)
def _dependencies_for_trail_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.trail_effect)
def _dependencies_for_sunlight_enter_exit_effect(self, asset_manager):
yield from asset_manager.get_dependencies_for_asset(self.sunlight_enter_exit_effect)
def _dependencies_for_phase_in_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.phase_in_sound)
def _dependencies_for_phase_out_sound(self, asset_manager):
yield from asset_manager.get_audio_group_dependency(self.phase_out_sound)
def dependencies_for(self, asset_manager):
for method, field_name, field_type in [
(self._dependencies_for_editor_properties, "editor_properties", "EditorProperties"),
(self._dependencies_for_patterned, "patterned", "PatternedAITypedef"),
(self._dependencies_for_actor_information, "actor_information", "ActorParameters"),
(self._dependencies_for_small_shot_projectile, "small_shot_projectile", "AssetId"),
(self._dependencies_for_small_shot_damage, "small_shot_damage", "DamageInfo"),
(self._dependencies_for_big_shot_projectile, "big_shot_projectile", "AssetId"),
(self._dependencies_for_big_shot_damage, "big_shot_damage", "DamageInfo"),
(self._dependencies_for_trail_effect, "trail_effect", "AssetId"),
(self._dependencies_for_sunlight_enter_exit_effect, "sunlight_enter_exit_effect", "AssetId"),
(self._dependencies_for_phase_in_sound, "phase_in_sound", "int"),
(self._dependencies_for_phase_out_sound, "phase_out_sound", "int"),
]:
try:
yield from method(asset_manager)
except Exception as e:
raise Exception(
f"Error finding dependencies for Lumite.{field_name} ({field_type}): {e}"
)
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={'leash_radius': 100.0, 'collision_radius': 0.10000000149011612, 'collision_height': 0.10000000149011612, 'step_up_height': 1.0, 'creature_size': 1})
def _decode_actor_information(data: typing.BinaryIO, property_size: int):
return ActorParameters.from_stream(data, property_size)
def _decode_unknown_0x2d9ebd7f(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x6dd1c509(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_small_shot_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_small_shot_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
def _decode_unknown_0x6d5356bb(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x2d1c2ecd(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_big_shot_projectile(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_big_shot_damage(data: typing.BinaryIO, property_size: int):
return DamageInfo.from_stream(data, property_size, default_override={'di_weapon_type': 11, 'di_damage': 5.0})
def _decode_trail_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_sunlight_enter_exit_effect(data: typing.BinaryIO, property_size: int):
return struct.unpack(">L", data.read(4))[0]
def _decode_unknown_0xe05d93ef(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_unknown_0x47691396(data: typing.BinaryIO, property_size: int):
return struct.unpack('>f', data.read(4))[0]
def _decode_phase_in_sound(data: typing.BinaryIO, property_size: int):
return struct.unpack('>l', data.read(4))[0]
def _decode_phase_out_sound(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),
0xb3774750: ('patterned', _decode_patterned),
0x7e397fed: ('actor_information', _decode_actor_information),
0x2d9ebd7f: ('unknown_0x2d9ebd7f', _decode_unknown_0x2d9ebd7f),
0x6dd1c509: ('unknown_0x6dd1c509', _decode_unknown_0x6dd1c509),
0x48157453: ('small_shot_projectile', _decode_small_shot_projectile),
0x7307c36b: ('small_shot_damage', _decode_small_shot_damage),
0x6d5356bb: ('unknown_0x6d5356bb', _decode_unknown_0x6d5356bb),
0x2d1c2ecd: ('unknown_0x2d1c2ecd', _decode_unknown_0x2d1c2ecd),
0xd05b1d24: ('big_shot_projectile', _decode_big_shot_projectile),
0xbdfe699d: ('big_shot_damage', _decode_big_shot_damage),
0x36eee791: ('trail_effect', _decode_trail_effect),
0xd2879ebb: ('sunlight_enter_exit_effect', _decode_sunlight_enter_exit_effect),
0xe05d93ef: ('unknown_0xe05d93ef', _decode_unknown_0xe05d93ef),
0x47691396: ('unknown_0x47691396', _decode_unknown_0x47691396),
0xa4231323: ('phase_in_sound', _decode_phase_in_sound),
0x3aaf7871: ('phase_out_sound', _decode_phase_out_sound),
} | /retro_data_structures-0.23.0-py3-none-any.whl/retro_data_structures/properties/echoes/objects/Lumite.py | 0.523664 | 0.253927 | Lumite.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.